duplicity 3.0.8.dev2__tar.gz → 3.0.8.dev4__tar.gz

{duplicity-3.0.8.dev2 → duplicity-3.0.8.dev4}/CHANGELOG.md

@@ -1,7 +1,29 @@
 
-(Unreleased) / 2025-12-31
-=========================
+rel.3.0.8.dev4 / 2026-03-31
+===========================
+
+ * c17b03bc:fix: try/except block masking real S3UploadFailedError
+ * db127ce5:new: Add --full-if-n-inc flag for count-based full backup.
+ * dc977419:fix: Simplify swig module definition.
+ * 0de30e69:chg: Adjust to newer sphinx.
+ * c1883117:fix: Add templates for bug and feature requests.
+ * 39150d34:fix: delete unused Path.patch_with_attribs.
+ * 1a7c6790:fix: Remove support for Python 2.
+ * 564dd593:fix: fix flag name --gpg-agent -> --use-agent.
+ * 866680d0:chg: Multiple changes for 2026 are planned
+ * 29e00b55:fix: Fix incompatibility with Python 3.14.
+ * 50faabfc:chg: Partial fix for #924.
+ * 00ae7687:fix: webdav, always send warmup OPTIONS request, prevent loop
+ * 37841a0e:fix: Handle local version identifiers in b2backend
+
+rel.3.0.8.dev3 / 2026-01-14
+===========================
+
+ * 3475dd05:fix: Unnecessary passphrase prompt with --encrypt-key --no-check-remote.
+ * b8508f6d:chg: Remove slow marker from tests.
 
+rel.3.0.8.dev2 / 2026-01-14
+===========================
 
 
 rel.3.0.7 / 2025-12-31

{duplicity-3.0.8.dev2/duplicity.egg-info → duplicity-3.0.8.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: duplicity
-Version: 3.0.8.dev2
+Version: 3.0.8.dev4
 Summary: Encrypted backup using rsync algorithm
 Author-email: Kenneth Loafman <kenneth@loafman.com>
 Maintainer: Edgar Soldin, Thomas Laubrock

{duplicity-3.0.8.dev2 → duplicity-3.0.8.dev4}/duplicity/__init__.py

@@ -21,7 +21,7 @@
 
 import gettext
 
-__version__: str = "3.0.8.dev2"
-__reldate__: str = "January 14, 2026"
+__version__: str = "3.0.8.dev4"
+__reldate__: str = "March 31, 2026"
 
 gettext.install("duplicity", names=["ngettext"])

{duplicity-3.0.8.dev2 → duplicity-3.0.8.dev4}/duplicity/_librsyncmodule.c

@@ -90,11 +90,7 @@ _librsync_sigmaker_cycle(_librsync_SigMakerObject *self, PyObject *args)
   rs_buffers_t buf;
   rs_result result;
 
-#if PY_MAJOR_VERSION >= 3
   if (!PyArg_ParseTuple(args, "y#:cycle", &inbuf, &inbuf_length))
-#else
-  if (!PyArg_ParseTuple(args, "s#:cycle", &inbuf, &inbuf_length))
-#endif
     return NULL;
 
   buf.next_in = inbuf;
@@ -110,11 +106,7 @@ _librsync_sigmaker_cycle(_librsync_SigMakerObject *self, PyObject *args)
     return NULL;
   }
 
-#if PY_MAJOR_VERSION >= 3
   return Py_BuildValue("(ily#)", (result == RS_DONE),
-#else
-  return Py_BuildValue("(ils#)", (result == RS_DONE),
-#endif
                        (long)inbuf_length - (long)buf.avail_in,
                        outbuf, RS_JOB_BLOCKSIZE - (long)buf.avail_out);
 }
@@ -178,11 +170,7 @@ _librsync_new_deltamaker(PyObject* self, PyObject* args)
   rs_buffers_t buf;
   rs_result result;
 
-#if PY_MAJOR_VERSION >= 3
   if (!PyArg_ParseTuple(args,"y#:new_deltamaker", &sig_string, &sig_length))
-#else
-  if (!PyArg_ParseTuple(args,"s#:new_deltamaker", &sig_string, &sig_length))
-#endif
     return NULL;
 
   dm = PyObject_New(_librsync_DeltaMakerObject, &_librsync_DeltaMakerType);
@@ -237,11 +225,7 @@ _librsync_deltamaker_cycle(_librsync_DeltaMakerObject *self, PyObject *args)
   rs_buffers_t buf;
   rs_result result;
 
-#if PY_MAJOR_VERSION >= 3
   if (!PyArg_ParseTuple(args, "y#:cycle", &inbuf, &inbuf_length))
-#else
-  if (!PyArg_ParseTuple(args, "s#:cycle", &inbuf, &inbuf_length))
-#endif
     return NULL;
 
   buf.next_in = inbuf;
@@ -256,11 +240,7 @@ _librsync_deltamaker_cycle(_librsync_DeltaMakerObject *self, PyObject *args)
     return NULL;
   }
 
-#if PY_MAJOR_VERSION >= 3
   return Py_BuildValue("(ily#)", (result == RS_DONE),
-#else
-  return Py_BuildValue("(ils#)", (result == RS_DONE),
-#endif
                        (long)inbuf_length - (long)buf.avail_in,
                        outbuf, RS_JOB_BLOCKSIZE - (long)buf.avail_out);
 }
@@ -374,11 +354,7 @@ _librsync_patchmaker_cycle(_librsync_PatchMakerObject *self, PyObject *args)
   rs_buffers_t buf;
   rs_result result;
 
-#if PY_MAJOR_VERSION >= 3
   if (!PyArg_ParseTuple(args, "y#:cycle", &inbuf, &inbuf_length))
-#else
-  if (!PyArg_ParseTuple(args, "s#:cycle", &inbuf, &inbuf_length))
-#endif
     return NULL;
 
   buf.next_in = inbuf;
@@ -393,11 +369,7 @@ _librsync_patchmaker_cycle(_librsync_PatchMakerObject *self, PyObject *args)
     return NULL;
   }
 
-#if PY_MAJOR_VERSION >= 3
   return Py_BuildValue("(ily#)", (result == RS_DONE),
-#else
-  return Py_BuildValue("(ils#)", (result == RS_DONE),
-#endif
                        (long)inbuf_length - (long)buf.avail_in,
                        outbuf, RS_JOB_BLOCKSIZE - (long)buf.avail_out);
 }
@@ -441,16 +413,6 @@ static PyTypeObject _librsync_PatchMakerType = {
 
 /* --------------- _librsync module definition */
 
-#if PY_MAJOR_VERSION >= 3
-#define MOD_DEF(ob, name, doc, methods) \
-  static struct PyModuleDef moduledef = { \
-    PyModuleDef_HEAD_INIT, name, doc, -1, methods, }; \
-  ob = PyModule_Create(&moduledef);
-#else
-#define MOD_DEF(ob, name, doc, methods) \
-  ob = Py_InitModule3(name, methods, doc);
-#endif
-
 static PyMethodDef _librsyncMethods[] = {
   {"new_sigmaker", _librsync_new_sigmaker, METH_VARARGS,
    "Return a sigmaker object, for finding the signature of an object"},
@@ -461,6 +423,9 @@ static PyMethodDef _librsyncMethods[] = {
   {NULL, NULL, 0, NULL}
 };
 
+static struct PyModuleDef moduledef = {
+  PyModuleDef_HEAD_INIT, "_librsync", "", -1, _librsyncMethods, };
+
 static PyObject *
 moduleinit(void)
 {
@@ -474,7 +439,7 @@ moduleinit(void)
   Py_TYPE(&_librsync_DeltaMakerType) = &PyType_Type;
   #endif
 
-  MOD_DEF(m, "_librsync", "", _librsyncMethods)
+  m = PyModule_Create(&moduledef);
   if (m == NULL)
       return NULL;
 
@@ -491,14 +456,7 @@ moduleinit(void)
   return m;
 }
 
-#if PY_MAJOR_VERSION < 3
-void init_librsync(void)
-{
-  moduleinit();
-}
-#else
 PyObject *PyInit__librsync(void)
 {
   return moduleinit();
 }
-#endif

{duplicity-3.0.8.dev2 → duplicity-3.0.8.dev4}/duplicity/backends/_cf_cloudfiles.py

@@ -39,10 +39,8 @@ class CloudFilesBackend(duplicity.backend.Backend):
             from cloudfiles import consts
             from cloudfiles.errors import NoSuchObject
         except ImportError as e:
-            raise BackendException(
-                f"""Cloudfiles backend requires the cloudfiles library available from Rackspace.
-Exception: {str(e)}"""
-            )
+            raise BackendException(f"""Cloudfiles backend requires the cloudfiles library available from Rackspace.
+Exception: {str(e)}""")
 
         self.resp_exc = ResponseError
         conn_kwargs = {}

{duplicity-3.0.8.dev2 → duplicity-3.0.8.dev4}/duplicity/backends/_cf_pyrax.py

@@ -37,10 +37,8 @@ class PyraxBackend(duplicity.backend.Backend):
         try:
             import pyrax
         except ImportError as e:
-            raise BackendException(
-                f"""Pyrax backend requires the pyrax library available from Rackspace.
-Exception: {str(e)}"""
-            )
+            raise BackendException(f"""Pyrax backend requires the pyrax library available from Rackspace.
+Exception: {str(e)}""")
 
         # Inform Pyrax that we're talking to Rackspace
         # per Jesus Monzon (gsusmonzon)

{duplicity-3.0.8.dev2 → duplicity-3.0.8.dev4}/duplicity/backends/b2backend.py

@@ -73,7 +73,8 @@ class B2Backend(duplicity.backend.Backend):
         try:  # figure out what version of b2sdk we have
             from b2sdk import __version__ as VERSION  # pylint: disable=import-error
 
-            v_split = VERSION.split(".")
+            v_public = VERSION.partition("+")[0]  # ignore local version identifier if present
+            v_split = v_public.split(".")
             self.v_num = [int(x) for x in v_split]
         except Exception as e:
             self.v_num = [0, 0, 0]

{duplicity-3.0.8.dev2 → duplicity-3.0.8.dev4}/duplicity/backends/dpbxbackend.py

@@ -120,11 +120,9 @@ class DPBXBackend(duplicity.backend.Backend):
             )
             from dropbox.oauth import DropboxOAuth2FlowNoRedirect
         except ImportError as e:
-            raise BackendException(
-                f"""This backend requires the dropbox package version 6.9.0
+            raise BackendException(f"""This backend requires the dropbox package version 6.9.0
 To install use "sudo pip install dropbox==6.9.0"
-Exception: {str(e)}"""
-            )
+Exception: {str(e)}""")
 
         self.api_account = None
         self.api_client = None

{duplicity-3.0.8.dev2 → duplicity-3.0.8.dev4}/duplicity/backends/gdrivebackend.py

@@ -38,11 +38,9 @@ class GDriveBackend(duplicity.backend.Backend):
             from googleapiclient.discovery import build
             from google.oauth2.service_account import Credentials
         except ImportError as e:
-            raise BackendException(
-                f"""GDrive backend requires Google API client installation.
+            raise BackendException(f"""GDrive backend requires Google API client installation.
 Please read the manpage for setup details.
-Exception: {str(e)}"""
-            )
+Exception: {str(e)}""")
 
         # Note Google has 2 drive methods, `Shared(previously Team) Drives` and `My Drive`
         #   both can be shared but require different addressing

{duplicity-3.0.8.dev2 → duplicity-3.0.8.dev4}/duplicity/backends/hubicbackend.py

@@ -38,10 +38,8 @@ class HubicBackend(PyraxBackend):
         try:
             import pyrax
         except ImportError as e:
-            raise BackendException(
-                f"""Hubic backend requires the pyrax library available from Rackspace.
-Exception: {str(e)}"""
-            )
+            raise BackendException(f"""Hubic backend requires the pyrax library available from Rackspace.
+Exception: {str(e)}""")
 
         # Inform Pyrax that we're talking to Hubic
         pyrax.set_setting("identity_type", "duplicity.backends.pyrax_identity.hubic.HubicIdentity")

{duplicity-3.0.8.dev2 → duplicity-3.0.8.dev4}/duplicity/backends/idrivedbackend.py

@@ -31,7 +31,6 @@ from duplicity import config
 from duplicity import log
 from duplicity.errors import BackendException
 
-
 #
 #   This backend works with the IDrive  "dedup implementation". V0.1
 #               (for all new and recent accounts)

{duplicity-3.0.8.dev2 → duplicity-3.0.8.dev4}/duplicity/backends/imapbackend.py

@@ -168,7 +168,7 @@ class ImapBackend(duplicity.backend.Backend):
         while allowedTimeout > 0:
             try:
                 self.conn.select(config.imap_mailbox)
-                (result, flist) = self.conn.search(None, "Subject", remote_filename)
+                result, flist = self.conn.search(None, "Subject", remote_filename)
                 if result != "OK":
                     raise Exception(flist[0])
 
@@ -176,7 +176,7 @@ class ImapBackend(duplicity.backend.Backend):
                 if flist[0] == "":
                     raise Exception("no mail with subject %s")
 
-                (result, flist) = self.conn.fetch(flist[0], "(RFC822)")
+                result, flist = self.conn.fetch(flist[0], "(RFC822)")
 
                 if result != "OK":
                     raise Exception(flist[0])
@@ -211,7 +211,7 @@ class ImapBackend(duplicity.backend.Backend):
 
     def _list(self):
         ret = []
-        (result, flist) = self.conn.select(config.imap_mailbox)
+        result, flist = self.conn.select(config.imap_mailbox)
         if result != "OK":
             raise BackendException(flist[0])
 
@@ -219,14 +219,14 @@ class ImapBackend(duplicity.backend.Backend):
         # address
 
         # Search returns an error if you haven't selected an IMAP folder.
-        (result, flist) = self.conn.search(None, "FROM", self.remote_dir)
+        result, flist = self.conn.search(None, "FROM", self.remote_dir)
         if result != "OK":
             raise Exception(flist[0])
         if flist[0] == b"":
             return ret
         nums = flist[0].strip().split(b" ")
         set = b"%s:%s" % (nums[0], nums[-1])  # pylint: disable=redefined-builtin
-        (result, flist) = self.conn.fetch(set, "(BODY[HEADER])")
+        result, flist = self.conn.fetch(set, "(BODY[HEADER])")
         if result != "OK":
             raise Exception(flist[0])
 
@@ -247,7 +247,7 @@ class ImapBackend(duplicity.backend.Backend):
         return ret
 
     def imapf(self, fun, *args):
-        (ret, flist) = fun(*args)
+        ret, flist = fun(*args)
         if ret != "OK":
             raise Exception(flist[0])
         return flist

{duplicity-3.0.8.dev2 → duplicity-3.0.8.dev4}/duplicity/backends/mediafirebackend.py

@@ -38,10 +38,8 @@ class MediafireBackend(duplicity.backend.Backend):
         try:
             import mediafire.client
         except ImportError as e:
-            raise BackendException(
-                f"""Mediafire backend requires the mediafire library.
-Exception: {str(e)}"""
-            )
+            raise BackendException(f"""Mediafire backend requires the mediafire library.
+Exception: {str(e)}""")
 
         duplicity.backend.Backend.__init__(self, parsed_url)
 

{duplicity-3.0.8.dev2 → duplicity-3.0.8.dev4}/duplicity/backends/onedrivebackend.py

@@ -34,7 +34,6 @@ from duplicity import log
 from duplicity import util
 from duplicity.errors import BackendException
 
-
 # For documentation on the API, see
 # The previous Live SDK API required the use of opaque folder IDs to navigate paths, but the Microsoft Graph
 # API allows the use of parent/child/grandchild pathnames.

{duplicity-3.0.8.dev2 → duplicity-3.0.8.dev4}/duplicity/backends/pcabackend.py

@@ -39,10 +39,8 @@ class PCABackend(duplicity.backend.Backend):
             from swiftclient import Connection
             from swiftclient import ClientException
         except ImportError as e:
-            raise BackendException(
-                f"""PCA backend requires the python-swiftclient library.
-Exception: {str(e)}"""
-            )
+            raise BackendException(f"""PCA backend requires the python-swiftclient library.
+Exception: {str(e)}""")
 
         self.resp_exc = ClientException
         self.conn_cls = Connection

{duplicity-3.0.8.dev2 → duplicity-3.0.8.dev4}/duplicity/backends/pyrax_identity/hubic.py

@@ -24,10 +24,8 @@ try:
     )
     import pyrax.exceptions as exc
 except ImportError as e:
-    raise BackendException(
-        f"""Hubic backend requires the pyrax library available from Rackspace.
-Exception: {str(e)}"""
-    )
+    raise BackendException(f"""Hubic backend requires the pyrax library available from Rackspace.
+Exception: {str(e)}""")
 
 OAUTH_ENDPOINT = "https://api.hubic.com/oauth/"
 API_ENDPOINT = "https://api.hubic.com/1.0/"

{duplicity-3.0.8.dev2 → duplicity-3.0.8.dev4}/duplicity/backends/rclonebackend.py

@@ -95,8 +95,10 @@ class RcloneBackend(duplicity.backend.Backend):
                 size = -1
             elif rc == 0:
                 size = int(o)
-        finally:
-            return {"size": size}
+        except Exception as e:
+            log.Debug(f"Failed to query file size for {remote_filename}: {e}")
+            return {"size": None}
+        return {"size": size}
 
     def _delete(self, remote_filename):
         remote_filename = os.fsdecode(remote_filename)

{duplicity-3.0.8.dev2 → duplicity-3.0.8.dev4}/duplicity/backends/rsyncbackend.py

@@ -60,7 +60,7 @@ class RsyncBackend(duplicity.backend.Backend):
             del os.environ["RSYNC_RSH"]
         if self.over_rsyncd():
             # its a module path
-            (path, port) = self.get_rsync_path()
+            path, port = self.get_rsync_path()
             self.url_string = f"{host}::{path.lstrip('/:')}"
             if port:
                 port = f" --port={port}"

{duplicity-3.0.8.dev2 → duplicity-3.0.8.dev4}/duplicity/backends/s3_boto3_backend.py

@@ -208,10 +208,11 @@ class S3Boto3Backend(duplicity.backend.Backend):
             )
         except S3UploadFailedError as e:
             if boto3.__version__ > "1.36.0" or botocore.__version__ > "1.36.0":
-                log.FatalError(
+                raise FatalBackendException(
                     f"Failed to upload file {remote_filename}, got S3UploadFailedError\n"
                     f"See https://gitlab.com/duplicity/duplicity/-/issues/870 for details.\n"
-                    f"Quick fix is: [sudo] pip3 install boto3<1.36.0 botocore<1.36.0"
+                    f"Quick fix is: [sudo] pip3 install boto3<1.36.0 botocore<1.36.0\n"
+                    f"API-Error: {e}"
                 )
             else:
                 raise e

{duplicity-3.0.8.dev2 → duplicity-3.0.8.dev4}/duplicity/backends/slatebackend.py

@@ -40,10 +40,8 @@ class SlateBackend(duplicity.backend.Backend):
         duplicity.backend.Backend.__init__(self, parsed_url)
         log.Debug("loading slate backend...")
         if "SLATE_API_KEY" not in os.environ.keys():
-            raise BackendException(
-                """You must set an environment variable SLATE_API_KEY
-                as the value of your slate API key"""
-            )
+            raise BackendException("""You must set an environment variable SLATE_API_KEY
+                as the value of your slate API key""")
         else:
             self.key = os.environ["SLATE_API_KEY"]
 

{duplicity-3.0.8.dev2 → duplicity-3.0.8.dev4}/duplicity/backends/ssh_paramiko_backend.py

@@ -104,13 +104,11 @@ class SSHParamikoBackend(duplicity.backend.Backend):
                 if hasattr(key, "fingerprint"):
                     fingerprints += f"\n  {key.fingerprint}"
                 keyname = key.get_name().upper()
-                question = dedent(
-                    """
+                question = dedent("""
                     The authenticity of host '{hostname}' can't be established.
                     {keyname} fingerprint is
                     {fingerprints}.
-                    Are you sure you want to continue connecting (yes/no)? """
-                ).format(**locals())
+                    Are you sure you want to continue connecting (yes/no)? """).format(**locals())
                 while True:
                     sys.stdout.write(question)
                     choice = input().lower()

{duplicity-3.0.8.dev2 → duplicity-3.0.8.dev4}/duplicity/backends/ssh_pexpect_backend.py

@@ -49,14 +49,12 @@ class SSHPExpectBackend(duplicity.backend.Backend):
             raise
 
         if pexpect.__version__ < "4.5.0":
-            log.FatalError(
-                f"""
+            log.FatalError(f"""
                 The version of pexpect, '{pexexpect.__version__}`, is too old.  We need version 4.5.0 or above to run.
                 See https://gitlab.com/duplicity/duplicity/-/issues/125 for the gory details.
 
                 Use "python3 -m pip install pexpect" to install the latest version.
-                """
-            )
+                """)
 
         self.retry_delay = 10
 

{duplicity-3.0.8.dev2 → duplicity-3.0.8.dev4}/duplicity/backends/swiftbackend.py

@@ -43,10 +43,8 @@ class SwiftBackend(duplicity.backend.Backend):
             from swiftclient import Connection
             from swiftclient import ClientException
         except ImportError as e:
-            raise BackendException(
-                f"""Swift backend requires the python-swiftclient library.
-Exception: {str(e)}"""
-            )
+            raise BackendException(f"""Swift backend requires the python-swiftclient library.
+Exception: {str(e)}""")
 
         self.resp_exc = ClientException
         conn_kwargs = {}

{duplicity-3.0.8.dev2 → duplicity-3.0.8.dev4}/duplicity/backends/webdavbackend.py

@@ -191,20 +191,18 @@ class WebDAVBackend(duplicity.backend.Backend):
         else:
             raise FatalBackendException(_("WebDAV Unknown URI scheme: %s") % self.parsed_url.scheme)
 
-        if self.username or self.password:
-            # Workaround cpython http.client issue
-            # https://github.com/python/cpython/issues/70107
-            # PUT may not return 401 when ran without basic-auth but throw SSL-EOF-Error or hang
-            # as a workaround we run an OPTIONS request that adds auth if needed and creates
-            # an authenticated connection to (re)use
-            response = self.request("OPTIONS", self.directory, None)
-            response.close()
+        # Workaround cpython http.client issue
+        # https://github.com/python/cpython/issues/70107
+        # PUT may not return a proper error when ran as first request but throw SSL-EOF-Error or hang
+        # as a workaround we run an OPTIONS request to make sure that PUT is never the first request
+        response = self.request("OPTIONS", self.directory, None, connect=False)
+        response.close()
 
     def _close(self):
         if self.conn:
             self.conn.close()
 
-    def request(self, method, path, data=None, redirected=0):
+    def request(self, method, path, data=None, redirected=0, connect=True):
         """
         Wraps the connection.request method to retry once if authentication is
         required
@@ -221,7 +219,8 @@ class WebDAVBackend(duplicity.backend.Backend):
             return headers_copy
 
         self._close()  # or we get previous request's data or exception
-        self.connect()
+        if connect:
+            self.connect()
 
         quoted_path = urllib.parse.quote(path, "/:~")
 
@@ -275,21 +274,12 @@ class WebDAVBackend(duplicity.backend.Backend):
             try:
                 return self.get_kerberos_authorization()
             except ImportError:
-                log.Warn(
-                    _(
-                        "python-kerberos needed to use kerberos \
-                          authorization, falling back to basic auth."
-                    )
-                )
+                log.Warn(_("python-kerberos needed to use kerberos \
+                          authorization, falling back to basic auth."))
                 return self.get_basic_authorization()
             except Exception as e:
-                log.Warn(
-                    _(
-                        "Kerberos authorization failed: %s.\
-                          Falling back to basic auth."
-                    )
-                    % e
-                )
+                log.Warn(_("Kerberos authorization failed: %s.\
+                          Falling back to basic auth.") % e)
                 return self.get_basic_authorization()
         elif token.lower() == "basic":
             return self.get_basic_authorization()

{duplicity-3.0.8.dev2 → duplicity-3.0.8.dev4}/duplicity/cli_data.py

@@ -354,6 +354,12 @@ OptionKwargs = dict(
         help="Perform full backup if last full is older than 'time'",
         default=dflt(config.full_if_older_than),
     ),
+    full_if_n_inc=dict(
+        metavar=_("number"),
+        type=int,
+        help="Perform full backup if latest chain has N or more incremental backups",
+        default=dflt(config.full_if_n_inc),
+    ),
     gpg_binary=dict(
         metavar=_("path"),
         type=check_file,
@@ -996,9 +1002,7 @@ trans = {
     "remote": _("remote"),
 }
 
-help_url_formats = (
-    _("Backends and their URL formats:")
-    + f"""
+help_url_formats = _("Backends and their URL formats:") + f"""
   azure://{trans['container_name']}
   b2://{trans['account_id']}[:{trans['application_key']}]@{trans['bucket_name']}/[{trans['some_dir']}/]
   boto3+s3://{trans['bucket_name']}[/{trans['prefix']}]
@@ -1033,4 +1037,3 @@ help_url_formats = (
   webdav://{trans['user']}[:{trans['password']}]@{trans['other_host']}/{trans['some_dir']}
   webdavs://{trans['user']}[:{trans['password']}]@{trans['other_host']}/{trans['some_dir']}
 """
-)

{duplicity-3.0.8.dev2 → duplicity-3.0.8.dev4}/duplicity/cli_main.py

@@ -173,37 +173,23 @@ def parse_cmdline_options(arglist):
     for opt in remainder:
         if opt.startswith("-"):
             if opt in changed_options:
-                command_line_error(
-                    dedent(
-                        f"""\
+                command_line_error(dedent(f"""\
                         Option '{opt} was changed in 2.0.0.
                             --file-to-restore to --path-to-restore
                             --do-not-restore-ownership to --no-restore-ownership
-                            """
-                    )
-                )
+                            """))
             elif opt in removed_options:
                 removed_commands_string = "\n".join(f"    {c}" for c in sorted(removed_options))
-                command_line_error(
-                    dedent(
-                        f"""\
+                command_line_error(dedent(f"""\
                         Option '{opt}' was removed in 2.0.0.
                         The following options were deprecated and removed in 2.0.0
-                        """
-                    )
-                    + f"{removed_commands_string}"
-                )
+                        """) + f"{removed_commands_string}")
             elif opt in removed_backup_options and args.action in ("backup", "full", "incremental"):
                 removed_commands_string = "\n".join(f"    {c}" for c in sorted(removed_backup_options))
-                command_line_error(
-                    dedent(
-                        f"""\
+                command_line_error(dedent(f"""\
                         Option '{opt}' was removed for backup actions in 2.0.0.
                         The following options were deprecated and removed in 2.0.0
-                        """
-                    )
-                    + f"{removed_commands_string}"
-                )
+                        """) + f"{removed_commands_string}")
 
     # check for proper action
     if remainder and remainder[0] in all_commands:
@@ -280,7 +266,7 @@ def process_command_line(cmdline_list):
         and len(config.gpg_profile.hidden_recipients) == 0
     ):
         log.Warn(
-            "Option --gpg-agent is unsafe with symmetric encryption.\n"
+            "Option --use-agent is unsafe with symmetric encryption.\n"
             "Refer to https://gitlab.com/duplicity/duplicity/-/issues/799 for more information."
         )