diff -Nru duplicity-0.8.18/bin/duplicity duplicity-0.8.19/bin/duplicity
--- duplicity-0.8.18/bin/duplicity	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/bin/duplicity	2021-04-29 18:20:20.000000000 +0000
@@ -56,39 +56,6 @@
     sys.stderr = codecs.getwriter(u'utf-8')(sys.stderr, u'replace')
 
 
-if u'--pydevd' in sys.argv or os.getenv(u'PYDEVD', None):
-    # modify this for your configuration.
-    # client = base path in machine that Liclipse is on
-    # server = base path in machine that duplicity is on
-    client = u'/Users/ken/workspace/duplicity-git'
-    server = u'/home/ken/workspace/duplicity-git'
-
-    # relative paths under duplicity root
-    duppaths = [
-        u'',
-        u'bin',
-        u'duplicity',
-        u'duplicity/backends',
-        u'testing',
-        u'testing/functional',
-        u'testing/unit',
-    ]
-    pathlist = [(os.path.normpath(os.path.join(client, p)),
-                 os.path.normpath(os.path.join(server, p))) for p in duppaths]
-    os.environ[u'PATHS_FROM_ECLIPSE_TO_PYTHON'] = json.dumps(pathlist)
-
-    import pydevd  # pylint: disable=import-error
-    pydevd.settrace(u'dione.local', port=5678, stdoutToServer=True, stderrToServer=True)
-
-    # In a dev environment the path is screwed so fix it.
-    base = sys.path.pop(0)
-    base = base.split(os.path.sep)[:-1]
-    base = os.path.sep.join(base)
-    sys.path.insert(0, base)
-
-log.setup()
-
-
 def with_tempdir(fn):
     u"""
     Execute function and guarantee cleanup of tempdir is called
@@ -108,12 +75,15 @@
 if __name__ == u"__main__":
     try:
 
+        util.start_debugger()
+
         #         import cProfile
         #         import pstats
         #         import StringIO
         #         prof = cProfile.Profile()
         #         prof.enable(subcalls=True, builtins=True)
 
+        log.setup()
         with_tempdir(main)
 
         #         prof.disable()
diff -Nru duplicity-0.8.18/bin/duplicity.1 duplicity-0.8.19/bin/duplicity.1
--- duplicity-0.8.18/bin/duplicity.1	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/bin/duplicity.1	2021-04-29 18:20:20.000000000 +0000
@@ -1146,6 +1146,9 @@
 will be reused instead.
 Otherwise, if passphrase is needed but not set the user will be prompted for it.
 
+Other environment variables may be used to configure specific backends.
+See the notes for the particular backend.
+
 .SH URL FORMAT
 Duplicity uses the URL format (as standard as possible) to define data locations.
 The generic format for a URL is:
@@ -1203,6 +1206,15 @@
 b2://account_id[:application_key]@bucket_name/[folder/]
 .RE
 .PP
+.BR "Box"
+.PP
+.RS
+box:///some_dir[?config=path_to_config]
+.PP
+See also
+.B "A NOTE ON BOX ACCESS"
+.RE
+.PP
 .BR "Cloud Files" " (Rackspace)"
 .PP
 .RS
@@ -1294,6 +1306,7 @@
 .PP
 .RS
 megav2://user[:password]@mega.nz/some_dir
+megav3://user[:password]@mega.nz/some_dir[?no_logout=1] (For latest MEGAcmd)
 .PP
 .B NOTE:
 despite "MEGAcmd" no longer uses a configuration file, for convenience storing the user password this backend searches it in the $HOME/.megav2rc file (same syntax as the old $HOME/.megarc)
@@ -1418,6 +1431,16 @@
 below.
 .RE
 .PP
+.BR "gdrive"
+.PP
+.RS
+gdrive://<service account' email address>@developer.gserviceaccount.com/some_dir
+.PP
+See also
+.B "A NOTE ON GDRIVE BACKEND"
+below.
+.RE
+.PP
 .BR "multi"
 .PP
 .RS
@@ -1758,22 +1781,22 @@
 See Amazon's documentation for details.
 
 .SH A NOTE ON AZURE ACCESS
-The Azure backend requires the Microsoft Azure Storage SDK for Python to be
-installed on the system.
+The Azure backend requires the Microsoft Azure Storage Blobs client library
+for Python to be installed on the system.
 See
-.B REQUIREMENTS
-above.
+.BR REQUIREMENTS .
+
+It uses the environment variable
+.BR AZURE_CONNECTION_STRING " (required)."
+This string contains all necessary information such as Storage Account name
+and the key for authentication.
+You can find it under Access Keys for the storage account.
 
-It uses environment variables for authentification:
-.BR AZURE_ACCOUNT_NAME " (required),"
-.BR AZURE_ACCOUNT_KEY " (optional),
-.BR AZURE_SHARED_ACCESS_SIGNATURE " (optional)."
-One of
-.BR AZURE_ACCOUNT_KEY " or"
-.BR AZURE_SHARED_ACCESS_SIGNATURE " is required."
+Duplicity will take care to create the container when performing the backup.
+Do not create it manually before.
 
-A container name must be a valid DNS name, conforming to the following naming
-rules:
+A container name (as given as the backup url) must be a valid DNS name,
+conforming to the following naming rules:
 
 .RS
 .IP 1.
@@ -1792,13 +1815,49 @@
 .IR
 .RE
 
+These rules come from Azure; see
+https://docs.microsoft.com/en-us/rest/api/storageservices/naming-and-referencing-containers--blobs--and-metadata
+
+.SH A NOTE ON BOX ACCESS
+The box backend requires boxsdk with jwt support to be installed on the system.
+See
+.BR REQUIREMENTS .
+
+It uses the environment variable
+.BR BOX_CONFIG_PATH " (optional)."
+This string contains the path to box custom app's config.json. Either this environment variable or
+the
+.BR config
+query parameter in the url need to be specified, if both are specified, query paramter takes precedence.
+
+.SS Create a Box custom app
+In order to use box backend, user need to create a box custom app in the box developer console (https://app.box.com/developers/console).
+
+After create a new custom app, please make sure it is configured as follow:
+
+.RS
+.IP 1.
+Choose "App Access Only" for "App Access Level"
+.IR
+.IP 2.
+Check "Write all files and folders stored in Box"
+.IR
+.IP 3.
+Generate a Public/Private Keypair
+.IR
+.RE
+
+The user also need to grant the created custom app permission in the
+admin console (https://app.box.com/master/custom-apps) by clicking
+the "+" button and enter the client_id which can be found on the custom
+app's configuration page.
+
 .SH A NOTE ON CLOUD FILES ACCESS
 Pyrax is Rackspace's next-generation Cloud management API, including
 Cloud Files access.  The cfpyrax backend requires the pyrax library to
 be installed on the system.
 See
-.B REQUIREMENTS
-above.
+.BR REQUIREMENTS .
 
 Cloudfiles is Rackspace's now deprecated implementation of OpenStack
 Object Storage protocol.  Users wishing to use Duplicity with Rackspace
@@ -1806,8 +1865,7 @@
 
 The backend requires python-cloudfiles to be installed on the system.
 See
-.B REQUIREMENTS
-above.
+.BR REQUIREMENTS .
 
 It uses three environment variables for authentification:
 .BR CLOUDFILES_USERNAME " (required),"
@@ -1937,7 +1995,8 @@
 https://code.google.com/apis/console#:storage:legacy
 
 .SH A NOTE ON HUBIC
-The hubic backend requires the pyrax library to be installed on the system. See REQUIREMENTS above.
+The hubic backend requires the pyrax library to be installed on the system. See
+.BR REQUIREMENTS .
 You will need to set your credentials for hubiC in a file called ~/.hubic_credentials, following this
 pattern:
 .PP
@@ -2060,8 +2119,7 @@
 
 .SH A NOTE ON PYDRIVE BACKEND
 The pydrive backend requires Python PyDrive package to be installed on the system. See
-.B REQUIREMENTS
-above.
+.BR REQUIREMENTS .
 
 There are two ways to use PyDrive: with a regular account or with a
 "service account". With a service account, a separate account is
@@ -2114,6 +2172,46 @@
 Duplicity. The credentials are then cached in the file references above
 for future use.
 
+.SH A NOTE ON GDRIVE BACKEND
+GDrive: is a rewritten PyDrive: backend with less dependencies, and a
+simpler setup - it uses the JSON keys downloaded directly from Google
+Cloud Console.
+
+There are two ways to use GDrive: with a regular account or with a
+"service account". With a service account, a separate account is
+created, that is only accessible with Google APIs and not a web login.
+With a regular account, you can store backups in your normal Google
+Drive.
+
+To use a service account, go to the Google developers console at
+https://console.developers.google.com. Create a project, and make sure
+Drive API is enabled for the project. In the "Credentials" section,
+click "Create credentials", then select Service Account with JSON key.
+
+The GOOGLE_SERVICE_JSON_FILE environment variable needs to contain the
+path to the JSON file on duplicity invocation.
+
+The alternative is to use a regular account. To do this, start as
+above, but when creating a new Client ID, select "Create OAuth client
+ID", with application type of "Desktop app". Download the
+client_secret.json file for the new client, and set the
+GOOGLE_CLIENT_SECRET_JSON_FILE environment variable to the path to
+this file, and GOOGLE_CREDENTIALS_FILE to a path to a file where
+duplicity will keep the authentication token - this location must be
+writable.
+
+During the first run, you will be prompted to visit an URL in your
+browser to grant access to your drive. Once granted, you will receive
+a verification code to paste back into Duplicity. The credentials are
+then cached in the file references above for future use.
+
+As a sanity check, GDrive checks the host and username from the URL
+against the JSON key, and refuses to proceed if the addresses do not
+match. Either the email (for the service accounts) or Client ID (for
+regular OAuth accounts) must be present in the URL. See
+.B URL FORMAT
+above.
+
 .SH A NOTE ON RCLONE BACKEND
 Rclone is a powerful command line program to sync files and directories to and from various cloud storage providers.
 .PP
@@ -2171,8 +2269,8 @@
 is a complete reimplementation of ssh protocols natively in python. Advantages
 are speed and maintainability. Minor disadvantage is that extra packages are
 needed as listed in
-.B REQUIREMENTS
-above. In
+.BR REQUIREMENTS .
+In
 .I sftp
 (default) mode all operations are done via the according sftp commands. In
 .I scp
@@ -2252,8 +2350,7 @@
 The backend requires python-switclient to be installed on the system.
 python-keystoneclient is also needed to use OpenStack's Keystone Identity service.
 See
-.B REQUIREMENTS
-above.
+.BR REQUIREMENTS .
 
 It uses following environment variables for authentification:
 .BR SWIFT_USERNAME " (required),"
@@ -2286,8 +2383,7 @@
 python-keystoneclient is also needed to interact with OpenStack's Keystone
 Identity service.
 See
-.B REQUIREMENTS
-above.
+.BR REQUIREMENTS .
 
 It uses following environment variables for authentification:
 .BR PCA_USERNAME " (required),"
@@ -2424,14 +2520,18 @@
 .B python-requests-oauthlib
 - https://github.com/requests/requests-oauthlib
 .TP
-.BR "azure backend" " (Azure Blob Storage Service)"
-.B Microsoft Azure Storage SDK for Python
-- https://pypi.python.org/pypi/azure-storage/
+.BR "azure backend" " (Azure Storage Blob Service)"
+.B Microsoft Azure Storage Blobs client library for Python
+- https://pypi.org/project/azure-storage-blob/
 .TP
 .BR "boto backend" " (S3 Amazon Web Services, Google Cloud Storage)"
 .B boto version 2.0+
 - http://github.com/boto/boto
 .TP
+.BR "box backend" " (box.com)"
+.B boxsdk
+- https://github.com/box/box-python-sdk
+.TP
 .BR "cfpyrax backend" " (Rackspace Cloud) and " "hubic backend" " (hubic.com)"
 .B Rackspace CloudFiles Pyrax API
 - http://docs.rackspace.com/sdks/guide/content/python.html
@@ -2462,7 +2562,7 @@
 .B megatools client
 - https://github.com/megous/megatools
 .TP
-.BR "MEGA v2 backend (works for all MEGA accounts)" " (mega.nz)"
+.BR "MEGA v2 and v3 backend (works for all MEGA accounts)" " (mega.nz)"
 .B MEGAcmd client
 - https://mega.nz/cmd
 .TP
@@ -2478,6 +2578,9 @@
 - http://www.ncftp.com/
 .TP
 .BR "OneDrive backend" " (Microsoft OneDrive)"
+.B python-requests
+- http://python-requests.org
+.br
 .B python-requests-oauthlib
 - https://github.com/requests/requests-oauthlib
 .TP
diff -Nru duplicity-0.8.18/CHANGELOG.md duplicity-0.8.19/CHANGELOG.md
--- duplicity-0.8.18/CHANGELOG.md	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/CHANGELOG.md	2021-04-29 18:20:20.000000000 +0000
@@ -1,9 +1,253 @@
+## rel.0.8.19 (2021-04-29)
+
+### New
+
+* Merge branch 'google-drive-v3' into 'master' [Kenneth Loafman]
+
+    Add a new Google Drive backend (gdrive:)
+
+    See merge request duplicity/duplicity!41
+
+### Changes
+
+* Remove installs common between before\_script: and script: [Kenneth Loafman]
+
+* Remove installs common between before\_script: and script: [Kenneth Loafman]
+
+### Fix
+
+* Gdata module passes on py27 only. [Kenneth Loafman]
+
+* Util.uexec() will return u'' if no err msg in e.args. [Kenneth Loafman]
+
+* Util.uexec() should check for e==None on entry. [Kenneth Loafman]
+
+* Fix bug #1547458 - more consistent passphrase prompt. [Kenneth Loafman]
+
+* Fixes bug #1454136 - SX backend issues. [Kenneth Loafman]
+
+* Fixes bug 1918981 - option to skip trash on delete on mediafire. [Kenneth Loafman]
+
+    Added --mf-purge option to bypass trash
+
+* Fix bug 1919017 - MultiBackend reports failure on file deletion. [Kenneth Loafman]
+
+* Fixes #41 - par2+rsync (non-ssh) fails. [Kenneth Loafman]
+
+### Other
+
+* Merge branch 'develop' into 'master' [Kenneth Loafman]
+
+    Fix Google Drive timeout
+
+    See merge request duplicity/duplicity!51
+
+* Fix "Giving up after 5 attempts. timeout: The read operation timed out" [Christian Perreault]
+
+* Merge branch 'master' into 'master' [Kenneth Loafman]
+
+    Don't sync when removing old backups
+
+    See merge request duplicity/duplicity!50
+
+* Don't sync when removing old backups. [Matthew Marting]
+
+* Merge branch 'fix-uexec-returns-None' into 'master' [Kenneth Loafman]
+
+    fix util.uexc: do not return None
+
+    See merge request duplicity/duplicity!49
+
+* Fix util.uexc: do not return None. [Michael Kopp]
+
+* Merge branch 'boxbackend' into 'master' [Kenneth Loafman]
+
+    Implement Box backend
+
+    See merge request duplicity/duplicity!48
+
+* Implement Box backend. [Jason Wu]
+
+* Merge branch 'megav3' into 'master' [Kenneth Loafman]
+
+    Implement megav3 backend to to cater for change in MEGACmd
+
+    See merge request duplicity/duplicity!47
+
+* Implement megav3 backend to to cater for change in MEGACmd. [Jason Wu]
+
+* Merge branch 'master' of git@gitlab.com:duplicity/duplicity.git. [Kenneth Loafman]
+
+* Merge branch 'use-new-azure-python-packages' into 'master' [Kenneth Loafman]
+
+    fix documentation for azure backend
+
+    See merge request duplicity/duplicity!46
+
+* Fix documentation for azure backend. [Michael Kopp]
+
+* Merge branch 'master' into 'master' [Kenneth Loafman]
+
+    Fix typo
+
+    See merge request duplicity/duplicity!45
+
+* Fix typo. [Moses Miller]
+
+* Merge branch 'master' into 'master' [Kenneth Loafman]
+
+    Add IDrive backend
+
+    See merge request duplicity/duplicity!43
+
+* Add IDrive backend. [SmilingM]
+
+* Merge branch 'master' into 'master' [Kenneth Loafman]
+
+    Progress bar improvements
+
+    Closes #49
+
+    See merge request duplicity/duplicity!44
+
+* Progress bar improvements. [Moses Miller]
+
+* Fix;usr:Fixes bug #1652953 - seek(0) on /dev/stdin crashes. [Kenneth Loafman]
+
+* Add a new Google Drive backend (gdrive:) [Jindřich Makovička]
+
+    - Removes the PyDrive/PyDrive2 dependencies, and depends only on the
+      Google API client libraries commonly available in distributions.
+
+    - Uses unchanged JSON secret files as downloaded from GCP
+
+    - Updates the Google Drive API to V3
+
+* Merge branch 'azurev12' into 'master' [Kenneth Loafman]
+
+    Azurev12
+
+    See merge request duplicity/duplicity!40
+
+* Replaced original azure implementation. [Erwin Bovendeur]
+
+* Fixed code smells. [Erwin Bovendeur]
+
+* Azure v12 support. [Erwin Bovendeur]
+
+* Revert "fix:pkg:Remove requirement for python3-pytest-runner.  Not used." [Kenneth Loafman]
+
+    This reverts commit 90e7e2acb6d158437cab3210114da46df72a7c85.
+
+* Merge branch 'feature/list-required-volumes-on-restore-dry-run' into 'master' [Kenneth Loafman]
+
+    List required volumes when called with 'restore --dry-run'
+
+    See merge request duplicity/duplicity!38
+
+* List required volumes when called with 'restore --dry-run' [Matthias Blankertz]
+
+    When restoring in dry-run mode, and with the manifest available, list
+    the volumes that would be gotten from the backend when actually
+    performing the operation.
+    This is intended to aid users of e.g. the S3 backend with (deep) glacier
+    storage, allowing the following workflow to recover files, optionally at
+    a certain time, from a long-term archive:
+    1. duplicity restore --dry-run [--file-to-restore <file/dir>] [--time <time>] boto3+s3://...
+    2. Start a Glacier restore process for all the listed volumes
+    3. duplicity restore [--file-to-restore <file/dir>] [--time <time>] boto3+s3://...
+
+* Merge branch 'swrmr-master-patch-23969' into 'master' [Kenneth Loafman]
+
+    Fix sorting of BackupSets by avoiding direct comparison
+
+    Closes #42
+
+    See merge request duplicity/duplicity!37
+
+* Fix sorting of BackupSets by avoiding direct comparison. [Stefan Wehrmeyer]
+
+    Sorting should only compare their time/end_time, not BackupSets directly
+    Closes #42
+
+* Merge branch 'master' of gitlab.com:duplicity/duplicity. [Kenneth Loafman]
+
+* Merge branch 'master' into 'master' [Kenneth Loafman]
+
+    Update mailing list link
+
+    See merge request duplicity/duplicity!36
+
+* Update mailing list link. [Chris Coutinho]
+
+* Merge branch 'master' of gitlab.com:duplicity/duplicity. [Kenneth Loafman]
+
+* Fixes #16 - Move from boto to boto3. [Kenneth Loafman]
+
+* Py27 EOL 01/2020, py35 EOL 01/2021, remove tests. [Kenneth Loafman]
+
+* Remove 2to3 from ub16 builds. [Kenneth Loafman]
+
+* Move py35 back to ub16, try 2. [Kenneth Loafman]
+
+* Move py35 back to ub16. [Kenneth Loafman]
+
+* Move py27 tests to ub16 and py35 tests to ub18. [Kenneth Loafman]
+
+* Fixes #16 - Move from boto to boto3. [Kenneth Loafman]
+
+* Py27 EOL 01/2020, py35 EOL 01/2021, remove tests. [Kenneth Loafman]
+
+* Move py27 tests to ub16 and py35 tests to ub18. [Kenneth Loafman]
+
+    Move py35 back to ub16.
+
+    Move py35 back to ub16, try 2.
+
+    Remove 2to3 from ub16 builds.
+
+* Fixes #33, remove quotes from identity filename option. [Kenneth Loafman]
+
+* Fix to correctly build \_librsync.so. [Kenneth Loafman]
+
+* Fix to add --inplace option to build\_ext. [Kenneth Loafman]
+
+* Rename pylintrc to .pylintrc. [Kenneth Loafman]
+
+* Merge branch 'fix-prefix-affinity-registration' into 'master' [Kenneth Loafman]
+
+* Multibackend: fix indentation error that was preventing from registering more than one affinity prefix per backend. [KheOps]
+
+* Move testfiles dir to a temp location. [Kenneth Loafman]
+
+    - was crashing LiClipse/Eclipse when present in project.
+    - so far only Darwin and Linux are supported, default Linux.
+    - Darwin uses 'getconf DARWIN_USER_TEMP_DIR' for temp dir.
+    - Linux uses TMPDIR, TEMP, or defaults to /tmp.
+
+* Merge remote-tracking branch 'alpha/testfiles' [Kenneth Loafman]
+
+* Update .gitlab-ci.yml to need code test to pass. [Kenneth Loafman]
+
+* Remove basepython in code and coverage tests. [Kenneth Loafman]
+
+* Add report.xml. [Kenneth Loafman]
+
+* Bulk replace testfiles with /tmp/testfiles. [Kenneth Loafman]
+
+* Skip unicode tests that fail on non-Linux systems like macOS. [Kenneth Loafman]
+
+
 ## rel.0.8.18 (2021-01-09)
 
 ### Other
 
 * Merge branch 'onedrive-token' into 'master' [Kenneth Loafman]
 
+    onedrive: Support using an external client id / refresh token
+
+    See merge request duplicity/duplicity!34
+
 * Onedrive: Support using an external client id / refresh token. [Michael Terry]
 
 * Update .gitlab-ci.yml to need code test to pass. [Kenneth Loafman]
@@ -18,8 +262,21 @@
 
 * Merge branch 'Rufflewind-master-patch-11811' into 'master' [Kenneth Loafman]
 
+    Report errors if B2 backend does exist but otherwise fails to import
+
+    See merge request duplicity/duplicity!33
+
 * Report errors if B2 backend does exist but otherwise fails to import. [Phil Ruffwind]
 
+    Sometimes import can fail because one of B2's dependencies is broken.
+
+    The trick here is to query the "name" attribute of ModuleNotFoundError
+    to see if B2 is the module that failed. Unfortunately this only works on
+    Python 3.6+. In older versions, the original behavior is retained.
+
+    This partially mitigates the issue described in
+    https://github.com/henrysher/duplicity/issues/14.
+
 * Add report.xml. [Kenneth Loafman]
 
 * Remove basepython in code and coverage tests. [Kenneth Loafman]
@@ -28,15 +285,20 @@
 
 * Added option --log-timestamp to prepend timestamp to log entry. [Kenneth Loafman]
 
+    The default is off so not to break anything, and is set to on when the
+    option is present.  A Catch-22 hack was made since we had to get options
+    for the log before adding a formatter, yet the commandline parser needs
+    the logger.  Went old school on it.
+
 * Merge branch 'master' of gitlab.com:duplicity/duplicity. [Kenneth Loafman]
 
 * Merge branch 'master' into 'master' [Kenneth Loafman]
 
-* Improve. [Gwyn Ciesla]
+    Patch for Python 3.10.
 
-* Change version for LP. [Kenneth Loafman]
+    See merge request duplicity/duplicity!32
 
-* Change version for LP. [Kenneth Loafman]
+* Improve. [Gwyn Ciesla]
 
 * Improve patch for Python 3.10. [Gwyn Ciesla]
 
@@ -63,14 +325,38 @@
 
 * Tools to make a CHANGELOG.md from git commits. [Kenneth Loafman]
 
+    $ [sudo] pip install gitchangelog
+
 * Merge branch 'exc-if-present-robust' into 'master' [Kenneth Loafman]
 
+    Make exclude-if-present more robust
+
+    See merge request duplicity/duplicity!31
+
 * Make exclude-if-present more robust. [Michael Terry]
 
+    Specifically, handle all the "common errors" when listing a directory
+    to see if the mentioned file is in it. Previously, we had done a
+    check for read access before listing. But it's safe to try to list
+    and just catch the errors that happen.
+
 * Merge branch 'no-umask' into 'master' [Kenneth Loafman]
 
+    Drop default umask of 0077
+
+    See merge request duplicity/duplicity!30
+
 * Drop default umask of 0077. [Michael Terry]
 
+    For most backends, it doesn't actually take effect. And it can be
+    confusing for people that back up to a drive that is ext4-formatted
+    but then try to restore on a new system.
+
+    If folks are worried about others accessing the backup files,
+    encryption is the recommended path for that.
+
+    https://gitlab.com/duplicity/duplicity/-/issues/24
+
 * Comment out RsyncBackendTest, again. [Kenneth Loafman]
 
 * Fix some unadorned strings. [Kenneth Loafman]
@@ -79,22 +365,40 @@
 
 * Merge branch 'Yump-issue-23' into 'master' [Kenneth Loafman]
 
+    Fix issue #23
+
+    Closes #23
+
+    See merge request duplicity/duplicity!29
+
 * Fix issue #23. [Yump]
 
+    Fix unicode crash on verify under python3, when symlinks have changed targets since the backup was taken.
+
 * Rclonebackend now logs at the same logging level as duplicity. [Kenneth Loafman]
 
 * Allow sign-build to fail on walk away.  Need passwordless option. [Kenneth Loafman]
 
 * Merge branch 'fix-rename' into 'master' [Kenneth Loafman]
 
+    Fix --rename typo
+
+    See merge request duplicity/duplicity!28
+
 * Fix --rename typo. [Michael Terry]
 
 * Move back to VM build, not remote.  Too many issues with remote. [Kenneth Loafman]
 
 * Merge branch 'escape-quote' into 'master' [Kenneth Loafman]
 
+    Escape single quotes in machine-readable log messages
+
+    See merge request duplicity/duplicity!27
+
 * Escape single quotes in machine-readable log messages. [Michael Terry]
 
+    https://gitlab.com/duplicity/duplicity/-/issues/21
+
 * Uncomment review-tools for snap. [Kenneth Loafman]
 
 * Whoops, missing wildcard '*'. [Kenneth Loafman]
@@ -119,7 +423,9 @@
 
 * Fix bug #1893481 Error when logging improperly encoded filenames. [Kenneth Loafman]
 
-* Change version for LP. [Kenneth Loafman]
+    - Reconfigure stdout/stderr to use errors='surrogateescape' in Python3
+    	and errors='replace' in Python2.
+      - Add a manual test case to check for regression.
 
 
 ## rel.0.8.16 (2020-09-29)
@@ -130,18 +436,44 @@
 
 * Merge branch 's3-unfreeze-all' into 'master' [Kenneth Loafman]
 
+    S3 unfreeze all
+
+    See merge request duplicity/duplicity!20
+
 * Wait for Glacier batch unfreeze to finish. [Marco Herrn]
 
+    The ThreadPoolExecutor starts the unfreezing of volumes in parallel.
+    However we can wait until it finishes its work for all volumes.
+
+    This currently does _not_ wait until the unfreezing process has
+    finished, but only until the S3 'restore()' operations have finished
+    (which can take a bit time).
+
+    The actual (sequential) pre_processing of the volumes to restore then
+    waits for the actual unfreezing to finish by regularly checking the
+    state of the unfreezing.
+
 * Adorn string as unicode. [Marco Herrn]
 
 * Utilize ThreadPoolExecutor for S3 glacier unfreeze. [Marco Herrn]
 
+    Starting one thread per file to unfreeze from Glacier can start a huge
+    amounts of threads in large backups.
+    Using a thread pool should cut this down to a more appropriate number of
+    threads.
+
 * Refine codestyle according to PEP-8. [Marco Herrn]
 
 * Adorn strings as unicode. [Marco Herrn]
 
 * S3 unfreeze all files at once. [Marco Herrn]
 
+    When starting a restore from S3 Glacier, start the unfreezing of all
+    volumes at once by calling botos 'restore()' method for each volume in a
+    separate thread.
+
+    This is only implemented in the boto backend, not in the boto3 backend.
+
 * Add boto3 to list of requirements. [Kenneth Loafman]
 
 * Remove ancient CVS Id macro. [Kenneth Loafman]
@@ -150,22 +482,51 @@
 
 * Merge branch 'paramiko-progress' into 'master' [Kenneth Loafman]
 
+    Fixes paramiko backend progress bar
+
+    See merge request duplicity/duplicity!26
+
 * Fixes paramiko backend progress bar. [Matteo Palazzo]
 
 * Merged in lazy init for Boto3 network connections. [Kenneth Loafman]
 
 * Merge branch 'feature/lazy\_init\_boto3' into 'master' [Kenneth Loafman]
 
+    lazy init for Boto3 network connections
+
+    See merge request duplicity/duplicity!25
+
 * Initial crack at lazy init for Boto3. [Carl Alexander Adams]
 
 * Merge branch 'hostname' into 'master' [Kenneth Loafman]
 
+    Record the hostname, not the fqdn, in manifest files
+
+    See merge request duplicity/duplicity!24
+
 * Record the hostname, not the fqdn, in manifest files. [Michael Terry]
 
+    We continue to check the fqdn as well, to keep backward
+    compatibility.
+
+    https://bugs.launchpad.net/duplicity/+bug/667885
+
 * Merge branch 'listdir-contains' into 'master' [Kenneth Loafman]
 
+    Avoid calling stat when checking for exclude-if-present files
+
+    See merge request duplicity/duplicity!23
+
 * Avoid calling stat when checking for exclude-if-present files. [Michael Terry]
 
+    If a folder with rw- permissions (i.e. read and write, but no exec)
+    is examined for the presence of an exclude-if-present file, we would
+    previously throw an exception when trying to stat the file during
+    Path object construction.
+
+    But we don't need to stat in this case. This patch just calls
+    listdir() and checks if the file is in that result.
+
 * Fix build control files after markdown conversion. [Kenneth Loafman]
 
 * Recover some changes lost after using web-ide. [Kenneth Loafman]
@@ -174,10 +535,27 @@
 
 * Merge branch 's3-boto3-region-and-endpoint' into 'master' [Kenneth Loafman]
 
+    Allow setting s3 region and endpoint
+
+    Closes #12
+
+    See merge request duplicity/duplicity!21
+
 * Set default values for s3\_region\_name and s3\_endpoint\_url. [Marco Herrn]
 
+    Fixes #12
+
 * Allow setting s3 region and endpoint. [Marco Herrn]
 
+    This commit introduces the new commandline options
+      --s3-region-name
+      --s3-endpoint-url
+    to specify these parameters. This allows using s3 compatible providers
+    like Scaleway or OVH.
+
+    It is probably useful for Amazon accounts, too, to have more fine
+    grained influence on the region to use.
+
 * Update README-REPO.md. [Kenneth Loafman]
 
 * Make code view consistent. [Kenneth Loafman]
@@ -190,6 +568,9 @@
 
 * Revert "Merge branch 's3-boto3-region-and-endpoint' into 'master'" [Kenneth Loafman]
 
+    This reverts commit f25e9740e17d24cf309aee136953d8fd51a7bf9b, reversing
+    changes made to 2890326dfd7a5bf9ea340aca76d96ebcd25aa8b6.
+
 * Bump version for LP dev build. [Kenneth Loafman]
 
 
@@ -201,14 +582,39 @@
 
 * Merge branch 's3-boto3-region-and-endpoint' into 'master' [Kenneth Loafman]
 
+    Allow setting s3 region and endpoint
+
+    See merge request duplicity/duplicity!19
+
 * Allow setting s3 region and endpoint. [Marco Herrn]
 
+    This commit introduces the new commandline options
+      --s3-region-name
+      --s3-endpoint-url
+    to specify these parameters. This allows using s3 compatible providers
+    like Scaleway or OVH.
+
+    It is probably useful for Amazon accounts, too, to have more fine
+    grained influence on the region to use.
+
 * Merge branch 'pydrive-notfound' into 'master' [Kenneth Loafman]
 
+    Fix missing FileNotUploadedError in pydrive backend
+
+    See merge request duplicity/duplicity!18
+
 * Fix missing FileNotUploadedError in pydrive backend. [Martin Sucha]
 
+    Since dadbe2d2c22751f68f179833d36c94f2777ba425, FileNotUploadedError
+    is not imported anymore, resulting in an exception in case
+    some of the files failed to upload. Adding the import back.
+
 * Merge branch 'pydriveshared' into 'master' [Kenneth Loafman]
 
+    Backend for Shared Drives on Google
+
+    See merge request duplicity/duplicity!17
+
 * Fixed indentation. [Joshua Chan]
 
 * Added shared drive support to existing `pydrive` backend instead of a new backend. [Joshua Chan]
@@ -221,28 +627,124 @@
 
 * Fix issue #10 - ppa:duplicity-*-git fails to install on Focal Fossa. [Kenneth Loafman]
 
+    - Set correct version requirements in debian/control.
+
 * Merge branch 'patch-2' into 'master' [Kenneth Loafman]
 
+    Remove python-cloudfiles from suggestions
+
+    See merge request duplicity/duplicity!16
+
 * Remove python-cloudfiles from suggestions. [Jairo Llopis]
 
+    This dependency cannot be installed on Python 3:
+
+    ```
+    #12 19.82   Downloading python-cloudfiles-1.7.11.tar.gz (330 kB)
+    #12 20.00     ERROR: Command errored out with exit status 1:
+    #12 20.00      command: /usr/local/bin/python -c 'import sys, setuptools, tokenize; sys.argv[0] = '"'"'/tmp/pip-install-2iwvh4bp/python-cloudfiles/setup.py'"'"'; __file__='"'"'/tmp/pip-install-2iwvh4bp/python-cloudfiles/setup.py'"'"';f=getattr(tokenize, '"'"'open'"'"', open)(__file__);code=f.read().replace('"'"'\r\n'"'"', '"'"'\n'"'"');f.close();exec(compile(code, __file__, '"'"'exec'"'"'))' egg_info --egg-base /tmp/pip-pip-egg-info-b1gvstfs
+    #12 20.00          cwd: /tmp/pip-install-2iwvh4bp/python-cloudfiles/
+    #12 20.00     Complete output (9 lines):
+    #12 20.00     Traceback (most recent call last):
+    #12 20.00       File "<string>", line 1, in <module>
+    #12 20.00       File "/tmp/pip-install-2iwvh4bp/python-cloudfiles/setup.py", line 6, in <module>
+    #12 20.00         from cloudfiles.consts import __version__
+    #12 20.00       File "/tmp/pip-install-2iwvh4bp/python-cloudfiles/cloudfiles/__init__.py", line 82, in <module>
+    #12 20.00         from cloudfiles.connection     import Connection, ConnectionPool
+    #12 20.00       File "/tmp/pip-install-2iwvh4bp/python-cloudfiles/cloudfiles/connection.py", line 13, in <module>
+    #12 20.00         from    urllib    import urlencode
+    #12 20.00     ImportError: cannot import name 'urlencode' from 'urllib' (/usr/local/lib/python3.8/urllib/__init__.py)
+    #12 20.00     ----------------------------------------
+    #12 20.00 ERROR: Command errored out with exit status 1: python setup.py egg_info Check the logs for full command output.
+    ```
+
+    Also, it is no longer supported. Rackspace uses `pyrax` nowadays. Removing to avoid confusions.
+
 * Merge branch 'patch-1' into 'master' [Kenneth Loafman]
 
+    Update azure requirement
+
+    See merge request duplicity/duplicity!15
+
 * Update azure requirement. [Jairo Llopis]
 
+    Trying to install `azure` today prints this error:
+
+    ```
+    Collecting azure
+      Downloading azure-5.0.0.zip (4.6 kB)
+        ERROR: Command errored out with exit status 1:
+         command: /usr/local/bin/python -c 'import sys, setuptools, tokenize; sys.argv[0] = '"'"'/tmp/pip-install-gzzfb6dp/azure/setup.py'"'"'; __file__='"'"'/tmp/pip-install-gzzfb6dp/azure/setup.py'"'"';f=getattr(tokenize, '"'"'open'"'"', open)(__file__);code=f.read().replace('"'"'\r\n'"'"', '"'"'\n'"'"');f.close();exec(compile(code, __file__, '"'"'exec'"'"'))' egg_info --egg-base /tmp/pip-pip-egg-info-1xop0k3_
+             cwd: /tmp/pip-install-gzzfb6dp/azure/
+        Complete output (24 lines):
+        Traceback (most recent call last):
+          File "<string>", line 1, in <module>
+          File "/tmp/pip-install-gzzfb6dp/azure/setup.py", line 60, in <module>
+            raise RuntimeError(message)
+        RuntimeError:
+
+        Starting with v5.0.0, the 'azure' meta-package is deprecated and cannot be installed anymore.
+        Please install the service specific packages prefixed by `azure` needed for your application.
+
+        The complete list of available packages can be found at:
+        https://aka.ms/azsdk/python/all
+
+        Here's a non-exhaustive list of common packages:
+
+        -  azure-mgmt-compute (https://pypi.python.org/pypi/azure-mgmt-compute) : Management of Virtual Machines, etc.
+        -  azure-mgmt-storage (https://pypi.python.org/pypi/azure-mgmt-storage) : Management of storage accounts.
+        -  azure-mgmt-resource (https://pypi.python.org/pypi/azure-mgmt-resource) : Generic package about Azure Resource Management (ARM)
+        -  azure-keyvault-secrets (https://pypi.python.org/pypi/azure-keyvault-secrets) : Access to secrets in Key Vault
+        -  azure-storage-blob (https://pypi.python.org/pypi/azure-storage-blob) : Access to blobs in storage accounts
+
+        A more comprehensive discussion of the rationale for this decision can be found in the following issue:
+        https://github.com/Azure/azure-sdk-for-python/issues/10646
+
+
+        ----------------------------------------
+    ```
+
+    So it's better to update this suggestion to `azure-mgmt-storage` instead.
+
 * Fix bug #1211481 with merge from Raffaele Di Campli. [Kenneth Loafman]
 
+    - Ignores the uid/gid from the archive and keeps the current user's
+    one.
+      - Recommended for restoring data to mounted filesystem which do not
+        support Unix ownership or when root privileges are not available.
+
 * Merge branch 'master' into 'master' [Kenneth Loafman]
 
+    Added `--do-not-restore-ownership` option
+
+    See merge request duplicity/duplicity!14
+
 * Added `--do-not-restore-ownership` option. [Jacotsu]
 
+    Ignores the uid/gid from the archive and keeps the current user's one.
+    Recommended for restoring data to mounted filesystem which do not
+    support Unix ownership or when root privileges are not available.
+
+    Solves launchpad bug #1211481
+
 * Fix bug #1887689 with patch from Matthew Barry. [Kenneth Loafman]
 
+    - Cleanup with Paramiko backend does not remove files due to missing
+        filename byte decoding
+
 * Bump version for LP build. [Kenneth Loafman]
 
 * Merge branch 'fix-glacier-check' into 'master' [Kenneth Loafman]
 
+    Fix check for s3 glacier/deep
+
+    See merge request duplicity/duplicity!13
+
 * Fix check for s3 glacier/deep. [Michael Terry]
 
+    This allows encryption validation to continue to work outside of
+    those s3 glacier/deep scenarios.
+
 * Change from push to upload. [Kenneth Loafman]
 
 * Add specific version for six. [Kenneth Loafman]
@@ -268,6 +770,10 @@
 
 * Merge branch 'mikix/rename-fix' into 'master' [Kenneth Loafman]
 
+    Fix --rename encoding
+
+    See merge request duplicity/duplicity!11
+
 * Fix --rename encoding. [Michael Terry]
 
 * Merge remote-tracking branch 'team/fix-py27-testing' [Kenneth Loafman]
@@ -292,10 +798,22 @@
 
 * Merge branch 'master' into 'master' [Kenneth Loafman]
 
+    Support PyDrive2 library in the pydrive backend
+
+    Unlike PyDrive, the PyDrive2 fork is actively maintained.
+
+    See merge request duplicity/duplicity!9
+
 * Support PyDrive2 library in the pydrive backend. [Jindrich Makovicka]
 
+    Unlike PyDrive, the PyDrive2 fork is actively maintained.
+
 * Merge branch 'Tidy\_up\_gitlab\_CI\_doc' into 'master' [Kenneth Loafman]
 
+    Tidy .gitlab-ci.yml, fix py3.5 test, add py2.7 test (allowed to fail)
+
+    See merge request duplicity/duplicity!7
+
 * Tidy .gitlab-ci.yml, fix py3.5 test, add py2.7 test (allowed to fail) [Aaron Whitehouse]
 
 * Merge branch 'fix-py27-CI' [Kenneth Loafman]
@@ -344,24 +862,69 @@
 
 * Merge branch 'add\_gitlab\_testing' into 'master' [Kenneth Loafman]
 
+    Add gitlab CI testing
+
+    See merge request duplicity/duplicity!3
+
 * Update .gitlab-ci.yml to update pip before installing other pip packages (to try to fix more-itertools issue: https://github.com/pytest-dev/pytest/issues/4770 ) [Aaron Whitehouse]
 
 * Don't include .git dir when building docker images. [Kenneth Loafman]
 
 * Merge branch 'update\_pip\_before\_install' into 'master' [Kenneth Loafman]
 
+    Upgrade pip before installing requirements with it. Fixes more-itertools error...
+
+    See merge request duplicity/duplicity!2
+
 * Upgrade pip before installing requirements with it. Fixes more-itertools error as newer versions of pip identify that the latest more-itertools are incompatible with python 2. [Aaron Whitehouse]
 
 * Patched in a megav2backend.py to update to MEGAcmd tools. [Kenneth Loafman]
 
+    - Author: Jose L. Domingo Lopez <github@24x7linux.com>
+      - Man pages, docs, etc. were included.
+
 * Change log.Warning to log.Warn.  Whoops! [Kenneth Loafman]
 
 * Fixed bug #1875937 - validate\_encryption\_settings() fails w/S3 glacier. [Kenneth Loafman]
 
+    - Skip validation with a warning if S3 glacier or deep storage
+    specified
+
 * Restore commented our backend requirements. [Kenneth Loafman]
 
 * Fixes for rclonebackend from Francesco Magno (original author) [Kenneth Loafman]
 
+    - copy command has been replaced with copyto, that is a specialized
+        version for single file operation. Performance-wise, we don't have
+        to include a single file in the local side directory, and we don't
+        have to list all the files in the remote to check what to
+    syncronize.
+        Additionally, we don't have to mess up with renaming because the
+        copy command didn't support changing filename during transfer
+        (because was oriented to transfer whole directories).
+      - delete command has been replaced with deletefile. Same here, we
+        have a specialized command for single file operation. Much more
+    efficient.
+      - ls command has been replaced with lsf, that is a specialized version
+        that returns only filenames. Since duplicity needs only those, less
+        bytes to transfer, and less parsing to do.
+      - lastly, I have reintroduced a custom subprocess function because the
+    one
+        inherithed from base class is checked, and throws an exception in
+    case of
+        non zero return code. The ls command family returns a non zero value
+    if
+        the directory does not exist in the remote, so starting a new backup
+        in a non existent directory is impossible at the moment because ls
+    fails
+        repeatedly until duplicity gives up. This is a bug in the current
+    implementation.
+        There is the same problem (but less severe) in _get method, using
+    the default
+        self.subprocess_popen a non zero return code will throw an exception
+    before we
+        can cleanup the partially downloaded file, if any.
+
 * Version man pages during setup.py install. [Kenneth Loafman]
 
 * More fixes for Launchpad build limitations. [Kenneth Loafman]
@@ -798,6 +1361,8 @@
 
 * In version 1 of the B2sdk, the list\_file\_names method is removed from the B2Bucket class. [Adam Jacobs]
 
+    This change makes the b2 backend backwards-compatible with the old version 0 AND forward-compatible with the new version 1.
+
 * Complete fix for string concatenation in b2 backend. [Adam Jacobs]
 
 * Fixed Resouce warnings when using paramiko.  It turns out   that duplicity's ssh\_paramiko\_backend.py was not handling   warning suppression and ended up clearing all warnings,   including those that default to off. [kenneth@loafman.com]
@@ -980,6 +1545,32 @@
 
 * Optimize loading backup chains; reduce file\_naming.parse calls. [Matthew Glazar]
 
+    For each filename in filename_list,
+    CollectionsStatus.get_backup_chains calls file_naming.parse
+    (through BackupSet.add_filename) between 0 and len(sets)*2
+    times. In the worst case, this leads to a *ton* of redundant
+    calls to file_naming.parse.
+
+    For example, when running 'duplicity collection-status' on
+    one of my backup directories:
+
+    * filename_list contains 7545 files
+    * get_backup_chains creates 2515 BackupSet-s
+    * get_backup_chains calls file_naming.parse 12650450 times!
+
+    This command took 9 minutes and 32 seconds. Similar
+    commands, like no-op incremental backups, also take a long
+    time. (The directory being backed up contains only 9 MiB
+    across 30 files.)
+
+    Avoid many redundant calls to file_naming.parse by hoisting
+    the call outside the loop over BackupSet-s. This
+    optimization makes 'duplicity collection-status' *20 times
+    faster* for me (572 seconds -> 29 seconds).
+
+    Aside from improving performance, this commit should not
+    change behavior.
+
 * Merged in lp:\~limburgher/duplicity/dropbox   - Fixes bug #1836611 dropbox mixing bytes and strings. [kenneth@loafman.com]
 
 * Correct types for os.join in Dropbox backend. [Gwyn Ciesla]
@@ -1061,6 +1652,9 @@
 
 * Fix Azure backend for python 3. [Frank Fischer]
 
+    By definition, the list of keys from "list" is byte-formatted.
+    As such we have to decode the parameter offered to "get"
+
 * Fixed bug #1831178 sequence item 0: expected str instance, int found   - Simply converted int to str when making list. [kenneth@loafman.com]
 
 * Fix some import conflicts with the "past" module   - Rename collections.py to dup\_collections.py   - Remove all "from future.utils import old\_div"   - Replace old\_div() with "//" (in py27 for a while).   - All tests run for py3, unit tests run for py3.  The new     import fail is "from future import standard\_library" [kenneth@loafman.com]
@@ -1073,6 +1667,8 @@
 
 * Have uexc to always return a string. [Michael Terry]
 
+    This fixes unhandled exception reporting
+
 * Add requirements for python-gettext. [kenneth@loafman.com]
 
 * Merged in lp:\~mterry/duplicity/gio-pydrive-fsdecode   - Fix gio and pydrive backends to use fsdecode. [kenneth@loafman.com]
@@ -1083,10 +1679,45 @@
 
 * Remove unnecessary sleeping after running backups in tests. [Matthew Glazar]
 
+    ptyprocess' 'PtyProcess.close' function [1] closes the
+    terminal, then terminates the process if it's still alive.
+    Before checking if the process is alive, ptyprocess
+    unconditionally sleeps for 100 milliseconds [2][3].
+
+    In 'run_duplicity', after we call 'child.wait()', we know
+    that the process is no longer alive. ptyprocess' 100 ms
+    sleep just slows down tests. Tell ptyprocess to not sleep.
+
+    [1] pexpect uses ptyprocess. 'PtyProcess.close' is called by
+        'PtyProcess.__del__', so 'PtyProcess.close' is called
+        when 'run_duplicity' returns.
+    [1] https://github.com/pexpect/ptyprocess/blob/3931cd45db50ee8533b8b0fef424b8d75f7ba1c2/ptyprocess/ptyprocess.py#L403
+    [2] https://github.com/pexpect/ptyprocess/blob/3931cd45db50ee8533b8b0fef424b8d75f7ba1c2/ptyprocess/ptyprocess.py#L173
+
 * Minimize time spent sleeping between backups. [Matthew Glazar]
 
+    During testing, if a backup completes at time 10:49:30.621,
+    the next call to 'backup' sleeps to ensure the new backup
+    has a different integer time stamp (10:49:31). Currently,
+    'backup' sleeps for an entire second, even though the next
+    integer time stamp is less than half a second away (0.379
+    seconds). This extra sleeping causes tests to take longer
+    than they need to.
+
+    Make tests run faster by sleeping only enough to reach the
+    next integer time stamp.
+
 * Ensure all duplicity output is captured in tests. [Matthew Glazar]
 
+    The loop in 'run_duplicity' which captures output has a race
+    condition. If duplicity writes output then exits before
+    'child.isalive()' is called, then 'run_duplicity' exits the
+    loop before calling 'child.readline()'. This means that some
+    output is not read into the 'lines' list.
+
+    Fix this race condition by reading all output until EOF,
+    then waiting for the child to exit.
+
 * Fix TestGlobToRegex.test\_glob\_to\_regex for py3.6 and above   - see https://bugs.python.org/issue29995 for details. [kenneth@loafman.com]
 
 * Some more work on unadorned strings   - Fixed test\_unadorned\_string\_literals to list all strings found   - Added bin/duplicity and bin/rdiffdir to list of files tested   - All unadorned strings have now been adorned. [kenneth@loafman.com]
@@ -1103,6 +1734,9 @@
 
 * Sync: handle parsed filenames without start/end times. [Mike Gorse]
 
+    Signatures set time, rather than start_time and end_time, so comparisons
+    against the latter generate an exception on Python 3.
+
 * More PEP 479 fixes. [Mike Gorse]
 
 * Fix some unadorned strings. [kenneth@loafman.com]
@@ -1145,6 +1779,8 @@
 
 * Attempt to port sx backend to python 3. [Mike Gorse]
 
+    Untested, but likely needed changes similar to some other backends.
+
 * Rsync: py3 fixes. [Mike Gorse]
 
 * Ncftp: py3 fixes. [Mike Gorse]
@@ -1153,6 +1789,10 @@
 
 * Fix sync\_archive on python 3. [Mike Gorse]
 
+    The recognized suffixes were being stored as unicode, but they were being
+    compared against filenames that are stored as bytes, so the comparisons
+    were failing.
+
 * Ssh\_pexpect: py3 fixes. [Mike Gorse]
 
 * Pull from main branch. [Mike Gorse]
diff -Nru duplicity-0.8.18/debian/changelog duplicity-0.8.19/debian/changelog
--- duplicity-0.8.18/debian/changelog	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/debian/changelog	2021-04-29 18:20:20.000000000 +0000
@@ -1,8 +1,8 @@
-duplicity (0.8.18-ppa202101091735~ubuntu21.04.1) hirsute; urgency=low
+duplicity (0.8.19-ppa202104291804~ubuntu21.04.1) hirsute; urgency=low
 
   * Auto build.
 
- -- Kenneth Loafman <kenneth@loafman.com>  Sat, 09 Jan 2021 17:50:18 +0000
+ -- Kenneth Loafman <kenneth@loafman.com>  Thu, 29 Apr 2021 18:20:20 +0000
 
 duplicity (0) UNRELEASED; urgency=low
 
diff -Nru duplicity-0.8.18/debian/git-build-recipe.manifest duplicity-0.8.19/debian/git-build-recipe.manifest
--- duplicity-0.8.18/debian/git-build-recipe.manifest	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/debian/git-build-recipe.manifest	2021-04-29 18:20:20.000000000 +0000
@@ -1,2 +1,2 @@
-# git-build-recipe format 0.4 deb-version 0.8.18-ppa202101091735
-lp:duplicity git-commit:ec0079bb6ea7166ec0a1cc6223188523b3a9bca1
+# git-build-recipe format 0.4 deb-version 0.8.19-ppa202104291804
+lp:duplicity git-commit:684dff91cd16bbda2013ae479adaa2478a47702e
diff -Nru duplicity-0.8.18/dist/makechangelog duplicity-0.8.19/dist/makechangelog
--- duplicity-0.8.18/dist/makechangelog	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/dist/makechangelog	2021-04-29 18:20:20.000000000 +0000
@@ -3,8 +3,9 @@
 set -e
 
 if [ "$#" -ne 0 ]; then
-    echo "usage: makepip"
+    echo "usage: makechangelog"
     exit 2
 fi
 
 gitchangelog > CHANGELOG.md
+git commit -m"Update changelog." CHANGELOG.md
diff -Nru duplicity-0.8.18/docs/duplicity.backends.gdrivebackend.rst duplicity-0.8.19/docs/duplicity.backends.gdrivebackend.rst
--- duplicity-0.8.18/docs/duplicity.backends.gdrivebackend.rst	1970-01-01 00:00:00.000000000 +0000
+++ duplicity-0.8.19/docs/duplicity.backends.gdrivebackend.rst	2021-04-29 18:20:20.000000000 +0000
@@ -0,0 +1,7 @@
+duplicity.backends.gdrivebackend module
+========================================
+
+.. automodule:: duplicity.backends.gdrivebackend
+   :members:
+   :undoc-members:
+   :show-inheritance:
diff -Nru duplicity-0.8.18/docs/testing.overrides.rst duplicity-0.8.19/docs/testing.overrides.rst
--- duplicity-0.8.18/docs/testing.overrides.rst	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/docs/testing.overrides.rst	2021-04-29 18:20:20.000000000 +0000
@@ -1,14 +1,6 @@
 testing.overrides package
 =========================
 
-Submodules
-----------
-
-.. toctree::
-   :maxdepth: 4
-
-   testing.overrides.gettext
-
 Module contents
 ---------------
 
diff -Nru duplicity-0.8.18/duplicity/backend.py duplicity-0.8.19/duplicity/backend.py
--- duplicity-0.8.18/duplicity/backend.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/duplicity/backend.py	2021-04-29 18:20:20.000000000 +0000
@@ -313,9 +313,9 @@
             if self.scheme in [u'rclone']:
                 pass
             # old style rsync://host::[/]dest, are still valid, though they contain no port
-            elif not (self.scheme in [u'rsync'] and re.search(u'::[^:]*$', self.url_string)):
+            elif not (u'rsync' in self.scheme and re.search(u'::[^:]*$', self.url_string)):
                 raise InvalidBackendURL(u"Syntax error (port) in: %s A%s B%s C%s" %
-                                        (url_string, (self.scheme in [u'rsync']),
+                                        (url_string, (u'rsync' in self.scheme),
                                          re.search(u'::[^:]+$', self.netloc), self.netloc))
 
         # Our URL system uses two slashes more than urlparse's does when using
diff -Nru duplicity-0.8.18/duplicity/backends/azurebackend.py duplicity-0.8.19/duplicity/backends/azurebackend.py
--- duplicity-0.8.18/duplicity/backends/azurebackend.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/duplicity/backends/azurebackend.py	2021-04-29 18:20:20.000000000 +0000
@@ -21,6 +21,7 @@
 
 from builtins import str
 import os
+import re
 
 import duplicity.backend
 from duplicity import config
@@ -29,6 +30,19 @@
 from duplicity.util import fsdecode
 
 
+_VALID_CONTAINER_NAME_RE = re.compile(r"^[a-z0-9](?!.*--)[a-z0-9-]{1,61}[a-z0-9]$")
+
+
+def _is_valid_container_name(name):
+    u"""
+    Check, whether the given name conforms to the rules as defined in
+    https://docs.microsoft.com/en-us/rest/api/storageservices/naming-and-referencing-containers--blobs--and-metadata
+    for valid names.
+    """
+    match = _VALID_CONTAINER_NAME_RE.match(name)
+    return match is not None
+
+
 class AzureBackend(duplicity.backend.Backend):
     u"""
     Backend for Azure Blob Storage Service
@@ -40,78 +54,43 @@
         try:
             import azure
             import azure.storage
-            if hasattr(azure.storage, u'BlobService'):
-                # v0.11.1 and below
-                from azure.storage import BlobService
-                self.AzureMissingResourceError = azure.WindowsAzureMissingResourceError
-                self.AzureConflictError = azure.WindowsAzureConflictError
-            else:
-                # v1.0.0 and above
-                import azure.storage.blob
-                if hasattr(azure.storage.blob, u'BlobService'):
-                    from azure.storage.blob import BlobService
-                else:
-                    from azure.storage.blob.blockblobservice import BlockBlobService as BlobService
-                self.AzureMissingResourceError = azure.common.AzureMissingResourceHttpError
-                self.AzureConflictError = azure.common.AzureConflictHttpError
+            import azure.storage.blob
+            from azure.storage.blob import BlobServiceClient
         except ImportError as e:
             raise BackendException(u"""\
-Azure backend requires Microsoft Azure Storage SDK for Python (https://pypi.python.org/pypi/azure-storage/).
+Azure backend requires Microsoft Azure Storage SDK for Python (https://pypi.org/project/azure-storage-blob/).
 Exception: %s""" % str(e))
 
-        # TODO: validate container name
-        self.container = parsed_url.path.lstrip(u'/')
+        self.container_name = parsed_url.path.lstrip(u'/')
+
+        if not _is_valid_container_name(self.container_name):
+            raise BackendException(u'Invalid Azure Storage Blob container name.')
 
-        if u'AZURE_ACCOUNT_NAME' not in os.environ:
-            raise BackendException(u'AZURE_ACCOUNT_NAME environment variable not set.')
+        if u'AZURE_CONNECTION_STRING' not in os.environ:
+            raise BackendException(u'AZURE_CONNECTION_STRING environment variable not set.')
 
-        if u'AZURE_ACCOUNT_KEY' in os.environ:
-            if u'AZURE_ENDPOINT_SUFFIX' in os.environ:
-                self.blob_service = BlobService(account_name=os.environ[u'AZURE_ACCOUNT_NAME'],
-                                                account_key=os.environ[u'AZURE_ACCOUNT_KEY'],
-                                                endpoint_suffix=os.environ[u'AZURE_ENDPOINT_SUFFIX'])
-            else:
-                self.blob_service = BlobService(account_name=os.environ[u'AZURE_ACCOUNT_NAME'],
-                                                account_key=os.environ[u'AZURE_ACCOUNT_KEY'])
-            self._create_container()
-        elif u'AZURE_SHARED_ACCESS_SIGNATURE' in os.environ:
-            if u'AZURE_ENDPOINT_SUFFIX' in os.environ:
-                self.blob_service = BlobService(account_name=os.environ[u'AZURE_ACCOUNT_NAME'],
-                                                sas_token=os.environ[u'AZURE_SHARED_ACCESS_SIGNATURE'],
-                                                endpoint_suffix=os.environ[u'AZURE_ENDPOINT_SUFFIX'])
-            else:
-                self.blob_service = BlobService(account_name=os.environ[u'AZURE_ACCOUNT_NAME'],
-                                                sas_token=os.environ[u'AZURE_SHARED_ACCESS_SIGNATURE'])
-        else:
-            raise BackendException(
-                u'Neither AZURE_ACCOUNT_KEY nor AZURE_SHARED_ACCESS_SIGNATURE environment variable not set.')
+        kwargs = {}
 
         if config.timeout:
-            self.blob_service.SOCKET_TIMEOUT = config.timeout
+            kwargs[u'timeout'] = config.timeout
 
         if config.azure_max_single_put_size:
-            # check if we use azure-storage>=0.30.0
-            try:
-                _ = self.blob_service.MAX_SINGLE_PUT_SIZE
-                self.blob_service.MAX_SINGLE_PUT_SIZE = config.azure_max_single_put_size
-            # fallback for azure-storage<0.30.0
-            except AttributeError:
-                self.blob_service._BLOB_MAX_DATA_SIZE = config.azure_max_single_put_size
+            kwargs[u'max_single_put_size'] = config.azure_max_single_put_size
 
         if config.azure_max_block_size:
-            # check if we use azure-storage>=0.30.0
-            try:
-                _ = self.blob_service.MAX_BLOCK_SIZE
-                self.blob_service.MAX_BLOCK_SIZE = config.azure_max_block_size
-            # fallback for azure-storage<0.30.0
-            except AttributeError:
-                self.blob_service._BLOB_MAX_CHUNK_DATA_SIZE = config.azure_max_block_size
+            kwargs[u'max_block_size'] = config.azure_max_single_put_size
+
+        conn_str = os.environ[u'AZURE_CONNECTION_STRING']
+        self.blob_service = BlobServiceClient.from_connection_string(conn_str, None, **kwargs)
+        self._get_or_create_container()
+
+    def _get_or_create_container(self):
+        from azure.core.exceptions import ResourceExistsError
 
-    def _create_container(self):
         try:
-            self.blob_service.create_container(self.container, fail_on_exist=True)
-        except self.AzureConflictError:
-            # Indicates that the resource could not be created because it already exists.
+            self.container = self.blob_service.get_container_client(self.container_name)
+            self.container.create_container()
+        except ResourceExistsError:
             pass
         except Exception as e:
             log.FatalError(u"Could not create Azure container: %s"
@@ -121,56 +100,45 @@
     def _put(self, source_path, remote_filename):
         remote_filename = fsdecode(remote_filename)
         kwargs = {}
+
         if config.azure_max_connections:
-            kwargs[u'max_connections'] = config.azure_max_connections
+            kwargs[u'max_concurrency'] = config.azure_max_connections
 
-        # https://azure.microsoft.com/en-us/documentation/articles/storage-python-how-to-use-blob-storage/#upload-a-blob-into-a-container
-        try:
-            self.blob_service.create_blob_from_path(self.container, remote_filename, source_path.name, **kwargs)
-        except AttributeError:  # Old versions use a different method name
-            self.blob_service.put_block_blob_from_path(self.container, remote_filename, source_path.name, **kwargs)
+        with source_path.open(u"rb") as data:
+            self.container.upload_blob(remote_filename, data, **kwargs)
 
         self._set_tier(remote_filename)
 
     def _set_tier(self, remote_filename):
         if config.azure_blob_tier is not None:
-            try:
-                self.blob_service.set_standard_blob_tier(self.container, remote_filename, config.azure_blob_tier)
-            except AttributeError:  # might not be available in old API
-                pass
+            self.container.set_standard_blob_tier_blobs(config.azure_blob_tier, remote_filename)
 
     def _get(self, remote_filename, local_path):
-        # https://azure.microsoft.com/en-us/documentation/articles/storage-python-how-to-use-blob-storage/#download-blobs
-        self.blob_service.get_blob_to_path(self.container, fsdecode(remote_filename), local_path.name)
+        # https://docs.microsoft.com/en-us/python/api/azure-storage-blob/azure.storage.blob.containerclient?view=azure-python#download-blob-blob--offset-none--length-none----kwargs-
+        blob = self.container.download_blob(remote_filename)
+        with local_path.open(u"wb") as download_file:
+            download_file.write(blob.readall())
 
     def _list(self):
-        # https://azure.microsoft.com/en-us/documentation/articles/storage-python-how-to-use-blob-storage/#list-the-blobs-in-a-container
+        # https://docs.microsoft.com/en-us/python/api/azure-storage-blob/azure.storage.blob.containerclient?view=azure-python#list-blobs-name-starts-with-none--include-none----kwargs-
         blobs = []
-        marker = None
-        while True:
-            batch = self.blob_service.list_blobs(self.container, marker=marker)
-            blobs.extend(batch)
-            if not batch.next_marker:
-                break
-            marker = batch.next_marker
+        blob_list = self.container.list_blobs()
+        for blob in blob_list:
+            blobs.append(blob)
+
         return [blob.name for blob in blobs]
 
     def _delete(self, filename):
-        # http://azure.microsoft.com/en-us/documentation/articles/storage-python-how-to-use-blob-storage/#delete-blobs
-        self.blob_service.delete_blob(self.container, fsdecode(filename))
+        # https://docs.microsoft.com/en-us/python/api/azure-storage-blob/azure.storage.blob.containerclient?view=azure-python#delete-blob-blob--delete-snapshots-none----kwargs-
+        self.container.delete_blob(fsdecode(filename))
 
     def _query(self, filename):
-        prop = self.blob_service.get_blob_properties(self.container, fsdecode(filename))
-        try:
-            info = {u'size': int(prop.properties.content_length)}
-        except AttributeError:
-            # old versions directly returned the properties
-            info = {u'size': int(prop[u'content-length'])}
-        return info
+        client = self.container.get_blob_client(fsdecode(filename))
+        prop = client.get_blob_properties()
+        return {u'size': int(prop.size)}
 
     def _error_code(self, operation, e):  # pylint: disable=unused-argument
-        if isinstance(e, self.AzureMissingResourceError):
-            return log.ErrorCode.backend_not_found
+        return log.ErrorCode.backend_not_found
 
 
 duplicity.backend.register_backend(u'azure', AzureBackend)
diff -Nru duplicity-0.8.18/duplicity/backends/boxbackend.py duplicity-0.8.19/duplicity/backends/boxbackend.py
--- duplicity-0.8.18/duplicity/backends/boxbackend.py	1970-01-01 00:00:00.000000000 +0000
+++ duplicity-0.8.19/duplicity/backends/boxbackend.py	2021-04-29 18:20:20.000000000 +0000
@@ -0,0 +1,222 @@
+# -*- Mode:Python; indent-tabs-mode:nil; tab-width:4; encoding:utf8 -*-
+#
+# Copyright 2020 Jose L. Domingo Lopez <github@24x7linux.com>
+#
+# This file is part of duplicity.
+#
+# Duplicity is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the
+# Free Software Foundation; either version 2 of the License, or (at your
+# option) any later version.
+#
+# Duplicity is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with duplicity; if not, write to the Free Software Foundation,
+# Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+from __future__ import print_function
+
+import os
+
+import duplicity.backend
+from boxsdk import Client, JWTAuth
+from duplicity.errors import BackendException
+from future import standard_library
+
+standard_library.install_aliases()
+
+
+class BoxBackend(duplicity.backend.Backend):
+    def __init__(self, parsed_url):
+        duplicity.backend.Backend.__init__(self, parsed_url)
+
+        self._client = self.get_box_client(parsed_url)
+        self._folder = (
+            parsed_url.path[1:]
+            if parsed_url.path[0] == u'/'
+            else parsed_url.path
+        )
+
+        self._file_to_metadata_map = {}
+        self._folder_id = self.get_id_from_path(self._folder)
+        if self._folder_id is None:
+            self._folder_id = self.makedirs(self._folder)
+
+    def get_box_client(self, parsed_url):
+        try:
+            config_path = os.path.expanduser(
+                parsed_url.query_args[u'config'][0]
+            )
+            return Client(JWTAuth.from_settings_file(config_path))
+        except Exception as e:
+            config_path = os.environ.get(u'BOX_CONFIG_PATH')
+            if config_path is not None:
+                try:
+                    return Client(JWTAuth.from_settings_file(config_path))
+                except Exception as e:
+                    raise BackendException(u'box config file is not found.')
+
+            raise BackendException(
+                u'box config file is not specified or not found.'
+            )
+
+    def _put(self, source_path, remote_filename):
+        u"""Uploads file to the specified remote folder
+        (tries to delete it first to make sure the new one can be uploaded)"""
+
+        try:
+            self.delete(remote_filename.decode())
+        except Exception:
+            pass
+        self.upload(
+            local_file=source_path.get_canonical().decode(),
+            remote_file=remote_filename.decode(),
+        )
+
+    def _get(self, remote_filename, local_path):
+        u'Downloads file from the specified remote path'
+
+        self.download(
+            remote_file=remote_filename.decode(),
+            local_file=local_path.name.decode(),
+        )
+
+    def _list(self):
+        u'Lists files in the specified remote path'
+
+        return self.folder_contents()
+
+    def _delete(self, filename):
+        u'Deletes file from the specified remote path'
+
+        self.delete(remote_file=filename.decode())
+
+    def _query_list(self, filename_list):
+        u'Query metadata for a list of file'
+        return {
+            filename: self._file_to_metadata_map.get(
+                filename.decode(), {u'size': -1}
+            )
+            for filename in filename_list
+        }
+
+    def get_id_from_path(self, remote_path, parent_id=u'0'):
+        u'Get the folder or file id from its path'
+        path_items = [
+            x.strip() for x in remote_path.split(u'/') if x.strip() != u''
+        ]
+        head = path_items[0]
+        tail = path_items[1:]
+
+        while True:
+            selected_item_id = None
+            for item in self._client.folder(folder_id=parent_id).get_items():
+                if item.name == head:
+                    selected_item_id = item.id
+                    break
+
+            if selected_item_id is None:
+                return None
+            elif len(tail) == 0:
+                return selected_item_id
+
+            parent_id = selected_item_id
+            head = tail[0]
+            tail = tail[1:]
+
+        return None
+
+    def get_file_id_from_filename(self, remote_filename):
+        u'Get the fild id by its file name'
+        file = self._file_to_metadata_map.get(remote_filename)
+
+        if file is not None:
+            return file[u'id']
+
+        file_id = self.get_id_from_path(
+            remote_filename, parent_id=self._folder_id
+        )
+        file = self._client.file(file_id).get()
+        self._file_to_metadata_map[file.name] = {
+            u'id': file.id,
+            u'size': file.size,
+        }
+        return file_id
+
+    def makedirs(self, remote_path):
+        u'Create folder(s) in a path if necessary'
+        path_items = [
+            x.strip() for x in remote_path.split(u'/') if x.strip() != u''
+        ]
+        parent_id = u'0'
+
+        start_folder_id = None
+        while len(path_items) > 0:
+            selected_item_id = None
+            for item in self._client.folder(folder_id=parent_id).get_items():
+                if item.name == path_items[0]:
+                    selected_item_id = item.id
+                    break
+
+            if selected_item_id is None:
+                start_folder_id = parent_id
+                break
+
+            parent_id = selected_item_id
+            path_items = path_items[1:]
+
+        if start_folder_id is not None:
+            parent_id = start_folder_id
+            for item in path_items:
+                subfolder = self._client.folder(parent_id).create_subfolder(
+                    item
+                )
+                parent_id = subfolder.id
+
+        return parent_id
+
+    def folder_contents(self):
+        u'Lists files of a remote box path'
+
+        items = [
+            x
+            for x in self._client.folder(folder_id=self._folder_id).get_items(
+                fields=[u'id', u'name', u'size']
+            )
+            if x.type == u'file'
+        ]
+
+        self._file_to_metadata_map.update(
+            {x.name: {u'id': x.id, u'size': x.size} for x in items}
+        )
+
+        return [x.name for x in items]
+
+    def upload(self, remote_file, local_file):
+        u'Upload local file to the box folder'
+        new_file = self._client.folder(self._folder_id).upload(
+            file_path=local_file, file_name=remote_file
+        )
+
+        self._file_to_metadata_map[new_file.name] = {
+            u'id': new_file.id,
+            u'size': new_file.size,
+        }
+
+    def download(self, remote_file, local_file):
+        u'Download file in box folder'
+        file_id = self.get_file_id_from_filename(remote_file)
+        with open(local_file, u'wb') as fp:
+            self._client.file(file_id).download_to(fp)
+
+    def delete(self, remote_file):
+        u'Delete file in box folder'
+        file_id = self.get_file_id_from_filename(remote_file)
+        self._client.file(file_id).delete()
+
+
+duplicity.backend.register_backend(u'box', BoxBackend)
diff -Nru duplicity-0.8.18/duplicity/backends/gdrivebackend.py duplicity-0.8.19/duplicity/backends/gdrivebackend.py
--- duplicity-0.8.18/duplicity/backends/gdrivebackend.py	1970-01-01 00:00:00.000000000 +0000
+++ duplicity-0.8.19/duplicity/backends/gdrivebackend.py	2021-04-29 18:20:20.000000000 +0000
@@ -0,0 +1,315 @@
+# -*- Mode:Python; indent-tabs-mode:nil; tab-width:4; encoding:utf8 -*-
+#
+# Copyright 2015 Yigal Asnis
+# Copyright 2021 Jindrich Makovicka
+#
+# This file is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the
+# Free Software Foundation; either version 2 of the License, or (at your
+# option) any later version.
+#
+# It is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with duplicity; if not, write to the Free Software Foundation,
+# Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+from builtins import str
+
+import os
+import pickle
+
+from duplicity import log
+from duplicity import util
+from duplicity.errors import BackendException
+import duplicity.backend
+
+
+class GDriveBackend(duplicity.backend.Backend):
+    u"""Connect to remote store using Google Drive API V3"""
+
+    PAGE_SIZE = 100
+    MIN_RESUMABLE_UPLOAD = 5 * 1024 * 1024
+
+    def __init__(self, parsed_url):
+        duplicity.backend.Backend.__init__(self, parsed_url)
+        try:
+            from googleapiclient.discovery import build
+            from google.oauth2.service_account import Credentials
+        except ImportError as e:
+            raise BackendException(u"""\
+GDrive backend requires Google API client installation.
+Please read the manpage for setup details.
+Exception: %s""" % str(e))
+
+        # Shared Drive ID specified as a query parameter in the backend URL.
+        # Example: gdrive://developer.gserviceaccount.com/target-folder/?driveID=<SHARED DRIVE ID>
+        self.shared_drive_corpora = {}
+        self.shared_drive_id = {}
+        self.shared_drive_flags_include = {}
+        self.shared_drive_flags_support = {}
+        if u'driveID' in parsed_url.query_args:
+            self.shared_drive_corpora = {u'corpora': u'drive'}
+            self.shared_drive_id = {u'driveId': parsed_url.query_args[u'driveID'][0]}
+            self.shared_drive_flags_include = {u'includeItemsFromAllDrives': True}
+            self.shared_drive_flags_support = {u'supportsAllDrives': True}
+
+        if parsed_url.username is not None:
+            client_id = parsed_url.username + u'@' + parsed_url.hostname
+        else:
+            client_id = parsed_url.hostname
+
+        if u'GOOGLE_SERVICE_JSON_FILE' in os.environ:
+            credentials = Credentials.from_service_account_file(os.environ[u'GOOGLE_SERVICE_JSON_FILE'])
+            if credentials.service_account_email != client_id:
+                raise BackendException(
+                    u'Service account email in the JSON file (%s) does not match the URL (%s)' %
+                    (credentials.service_account_email, client_id))
+
+        elif u'GOOGLE_CLIENT_SECRET_JSON_FILE' in os.environ and u'GOOGLE_CREDENTIALS_FILE' in os.environ:
+            from google_auth_oauthlib.flow import InstalledAppFlow
+            from google.auth.transport.requests import Request
+
+            credentials = None
+            if os.path.exists(os.environ[u'GOOGLE_CREDENTIALS_FILE']):
+                with open(os.environ[u'GOOGLE_CREDENTIALS_FILE'], u'rb') as token:
+                    credentials = pickle.load(token)
+
+            # If there are no (valid) credentials available, let the user log in.
+            if not credentials or not credentials.valid:
+                if credentials and credentials.expired and credentials.refresh_token:
+                    credentials.refresh(Request())
+                else:
+                    flow = InstalledAppFlow.from_client_secrets_file(
+                        os.environ[u'GOOGLE_CLIENT_SECRET_JSON_FILE'],
+                        u'https://www.googleapis.com/auth/drive.file')
+
+                    if flow.client_config[u'client_id'] != client_id:
+                        raise BackendException(
+                            u'Client ID in the JSON file (%s) does not match the URL (%s)' %
+                            (flow.client_config.client_id, client_id))
+
+                    credentials = flow.run_console()
+                # Save the credentials for the next run
+                with open(os.environ[u'GOOGLE_CREDENTIALS_FILE'], u'wb') as token:
+                    pickle.dump(credentials, token)
+
+            if credentials.client_id != client_id:
+                raise BackendException(
+                    u'Client ID in the credentials file (%s) does not match the URL (%s)' %
+                    (credentials.client_id, client_id))
+
+        else:
+            raise BackendException(
+                u'GOOGLE_SERVICE_JSON_FILE or GOOGLE_CLIENT_SECRET_JSON_FILE environment '
+                u'variable not set. Please read the manpage to fix.')
+
+        self.drive = build(u'drive', u'v3', credentials=credentials)
+
+        if self.shared_drive_id:
+            parent_folder_id = self.shared_drive_id[u'driveId']
+        else:
+            parent_folder_id = u'root'
+
+        # Fetch destination folder entry and create hierarchy if required.
+        folder_names = parsed_url.path.split(u'/')
+        for folder_name in folder_names:
+            if not folder_name:
+                continue
+            q = (u"name = '" + folder_name + u"' and '" + parent_folder_id +
+                 u"' in parents and mimeType = 'application/vnd.google-apps.folder' and trashed=false")
+            results = self.drive.files().list(q=q,
+                                              pageSize=1,
+                                              fields=u"files(name,id),nextPageToken",
+                                              **self.shared_drive_corpora,
+                                              **self.shared_drive_id,
+                                              **self.shared_drive_flags_include,
+                                              **self.shared_drive_flags_support).execute()
+            file_list = results.get(u'files', [])
+
+            if len(file_list) == 0:
+                file_metadata = {u'name': folder_name,
+                                 u'mimeType': u"application/vnd.google-apps.folder",
+                                 u'parents': [parent_folder_id]}
+                file_metadata.update(self.shared_drive_id)
+                folder = self.drive.files().create(body=file_metadata,
+                                                   fields=u'id',
+                                                   **self.shared_drive_flags_support).execute()
+            else:
+                folder = file_list[0]
+
+            parent_folder_id = folder[u'id']
+
+        self.folder = parent_folder_id
+        self.id_cache = {}
+
+    def file_by_name(self, filename):
+        from googleapiclient.errors import HttpError
+
+        filename = util.fsdecode(filename)
+
+        if filename in self.id_cache:
+            # It might since have been locally moved, renamed or deleted, so we
+            # need to validate the entry.
+            file_id = self.id_cache[filename]
+            try:
+                drive_file = self.drive.files().get(fileId=file_id,
+                                                    fields=u'id,size,name,parents,trashed',
+                                                    **self.shared_drive_flags_support).execute()
+                if drive_file[u'name'] == filename and not drive_file[u'trashed']:
+                    for parent in drive_file[u'parents']:
+                        if parent == self.folder:
+                            log.Info(u"GDrive backend: found file '%s' with id %s in ID cache" %
+                                     (filename, file_id))
+                            return drive_file
+            except HttpError as error:
+                # A 404 occurs if the ID is no longer valid
+                if error.resp.status != 404:
+                    raise
+            # If we get here, the cache entry is invalid
+            log.Info(u"GDrive backend: invalidating '%s' (previously ID %s) from ID cache" %
+                     (filename, file_id))
+            del self.id_cache[filename]
+
+        # Not found in the cache, so use directory listing. This is less
+        # reliable because there is no strong consistency.
+        q = u"name = '%s' and '%s' in parents and trashed = false" % (filename, self.folder)
+        results = self.drive.files().list(q=q, fields=u'files(name,id,size),nextPageToken',
+                                          pageSize=2,
+                                          **self.shared_drive_corpora,
+                                          **self.shared_drive_id,
+                                          **self.shared_drive_flags_include,
+                                          **self.shared_drive_flags_support).execute()
+        file_list = results.get(u'files', [])
+        if len(file_list) > 1:
+            log.FatalError(u"GDrive backend: multiple files called '%s'." % (filename,))
+        elif len(file_list) > 0:
+            file_id = file_list[0][u'id']
+            self.id_cache[filename] = file_list[0][u'id']
+            log.Info(u"GDrive backend: found file '%s' with id %s on server, "
+                     u"adding to cache" % (filename, file_id))
+            return file_list[0]
+
+        log.Info(u"GDrive backend: file '%s' not found in cache or on server" %
+                 (filename,))
+        return None
+
+    def id_by_name(self, filename):
+        drive_file = self.file_by_name(filename)
+        if drive_file is None:
+            return u''
+        else:
+            return drive_file[u'id']
+
+    def _put(self, source_path, remote_filename):
+        from googleapiclient.http import MediaFileUpload
+
+        remote_filename = util.fsdecode(remote_filename)
+        drive_file = self.file_by_name(remote_filename)
+        if remote_filename.endswith(u'.gpg'):
+            mime_type = u'application/pgp-encrypted'
+        else:
+            mime_type = u'text/plain'
+
+        file_size = os.path.getsize(source_path.name)
+        if file_size >= self.MIN_RESUMABLE_UPLOAD:
+            resumable = True
+            num_retries = 5
+        else:
+            resumable = False
+            num_retries = 0
+
+        media = MediaFileUpload(source_path.name, mimetype=mime_type, resumable=resumable)
+        if drive_file is None:
+            # No existing file, make a new one
+            file_metadata = {u'name': remote_filename, u'parents': [self.folder]}
+            file_metadata.update(self.shared_drive_id)
+            log.Info(u"GDrive backend: creating new file '%s'" % (remote_filename,))
+            drive_file = self.drive.files().create(
+                body=file_metadata,
+                media_body=media,
+                **self.shared_drive_flags_support).execute(num_retries=num_retries)
+        else:
+            log.Info(u"GDrive backend: replacing existing file '%s' with id '%s'" % (
+                remote_filename, drive_file[u'id']))
+            drive_file = self.drive.files().update(
+                media_body=media,
+                fileId=drive_file[u'id'],
+                **self.shared_drive_flags_support).execute(num_retries=num_retries)
+
+        self.id_cache[remote_filename] = drive_file[u'id']
+
+    def _get(self, remote_filename, local_path):
+        from googleapiclient.http import MediaIoBaseDownload
+
+        drive_file = self.file_by_name(remote_filename)
+        request = self.drive.files().get_media(fileId=drive_file[u'id'],
+                                               **self.shared_drive_flags_support)
+        with open(util.fsdecode(local_path.name), u"wb") as fh:
+            done = False
+            downloader = MediaIoBaseDownload(fh, request)
+            while done is False:
+                status, done = downloader.next_chunk()
+
+    def _list(self):
+        page_token = None
+        drive_files = []
+        while True:
+            response = self.drive.files().list(
+                q=u"'" + self.folder + u"' in parents and trashed=false",
+                pageSize=self.PAGE_SIZE,
+                fields=u"files(name,id),nextPageToken",
+                pageToken=page_token,
+                **self.shared_drive_corpora,
+                **self.shared_drive_id,
+                **self.shared_drive_flags_include,
+                **self.shared_drive_flags_support).execute()
+
+            drive_files += response.get(u'files', [])
+
+            page_token = response.get(u'nextPageToken', None)
+            if page_token is None:
+                break
+
+        filenames = set(item[u'name'] for item in drive_files)
+        # Check the cache as well. A file might have just been uploaded but
+        # not yet appear in the listing.
+        # Note: do not use iterkeys() here, because file_by_name will modify
+        # the cache if it finds invalid entries.
+        for filename in list(self.id_cache.keys()):
+            if (filename not in filenames) and (self.file_by_name(filename) is not None):
+                filenames.add(filename)
+        return list(filenames)
+
+    def _delete(self, filename):
+        file_id = self.id_by_name(filename)
+        if file_id == u'':
+            log.Warn(u"File '%s' does not exist while trying to delete it" % (util.fsdecode(filename),))
+        else:
+            self.drive.files().delete(fileId=file_id,
+                                      **self.shared_drive_flags_support).execute()
+
+    def _query(self, filename):
+        drive_file = self.file_by_name(filename)
+        if drive_file is None:
+            size = -1
+        else:
+            size = int(drive_file[u'size'])
+        return {u'size': size}
+
+    def _error_code(self, operation, error):  # pylint: disable=unused-argument
+        from google.auth.exceptions import RefreshError
+        from googleapiclient.errors import HttpError
+        if isinstance(error, HttpError):
+            return log.ErrorCode.backend_not_found
+        elif isinstance(error, RefreshError):
+            return log.ErrorCode.backend_permission_denied
+        return log.ErrorCode.backend_error
+
+
+duplicity.backend.register_backend(u'gdrive', GDriveBackend)
+
+duplicity.backend.uses_netloc.extend([u'gdrive'])
diff -Nru duplicity-0.8.18/duplicity/backends/idrivedbackend.py duplicity-0.8.19/duplicity/backends/idrivedbackend.py
--- duplicity-0.8.18/duplicity/backends/idrivedbackend.py	1970-01-01 00:00:00.000000000 +0000
+++ duplicity-0.8.19/duplicity/backends/idrivedbackend.py	2021-04-29 18:20:20.000000000 +0000
@@ -0,0 +1,469 @@
+# -*- Mode:Python; indent-tabs-mode:nil; tab-width:4 -*-
+#
+# Copyright 2021 Menno Smits <menno@smi-ling.nl>
+#
+# This file is part of duplicity.
+#
+# Duplicity is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the
+# Free Software Foundation; either version 2 of the License, or (at your
+# option) any later version.
+#
+# Duplicity is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with duplicity; if not, write to the Free Software Foundation,
+# Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+import os
+import urllib
+import tempfile
+import re
+import xml.etree.ElementTree as ET
+import shutil
+import errno
+
+
+import duplicity.backend
+from duplicity import config
+from duplicity import log
+from duplicity import tempdir
+from duplicity import progress
+from duplicity.errors import BackendException
+
+#
+#   This backend works with the IDrive  "dedup implementation". V0.1
+#               (for all new and recent accounts)
+#
+#   Credits: This code is loosely inspired by the work of <aappddeevv>
+#
+#
+#   This backend uses an intermediate driver for IDrive: "idevsutil_dedup" that will be
+#   installed automagically  when you perform the account setup on your system.
+#   It can, however, also be downloaded directly from the following URL's
+#
+#   https://www.idrivedownloads.com/downloads/linux/download-options/IDrive_linux_64bit.zip
+#   and
+#   https://www.idrivedownloads.com/downloads/linux/download-options/IDrive_linux_32bit.zip
+#
+#   for 32 and 64 bit linux, respectively. Copy the file anywhere with exe permissions.
+#   (no further setup of your IDrive account is needed for idrived to work)
+#
+#
+#   For this backend to work, you need to create a number of environment variables:
+#
+#   - Put the absolute path to the driver-file (idevsutil_dedup) in IDEVSPATH
+#   - Put the account-name (login name) in IDRIVEID
+#
+#   - Put the name of the desired bucket for this backup-session in IDBUCKET
+#     If this bucket does not exist it will be created at runtime
+#
+#   - Create a file with the account password - put absolute path in IDPWDFILE
+#
+#   When using a custom encryption key:
+#   - Create a file with the encryption key - put absolute path in IDKEYFILE
+#
+#   Note: setup proper security for these files!
+#
+#
+#   The IDrive "root" issue ...
+#
+#   IDrive stores files according to 1) the selected bucket, 2) the supplied path
+#   and 3)the absolute path of the directory used for uploads. So ... if we use
+#       - bucket <MYBUCKET>
+#       - duplicity commandline idrived://DUPLICITY
+#   and
+#       - system tempfile OR path set from --tempfile "\tmp"
+#
+#   the files end-up in the following path:
+#       <MYBUCKET>/DUPLICITY/tmp/duplicity-??????-tempdir
+#
+#   Not only is this SO UGLY .... but - as tempdirs have unique names - this effectively
+#   disables the idea of incremental backups.
+#
+#   To remedy this, idrived uses the concept of a "fakeroot" directory, defined via the
+#   --idr-fakeroot=... switch. This can be an existing directory, or the directory is
+#   created at runtime on the root of the (host) files system. (cave: you have to have
+#   write access to the root!). Directories created at runtime are auto-removed on exit!
+#
+#   So, in the above scheme, we could do:
+#       duplicity --idr-fakeroot=nicepath idrived://DUPLICITY
+#
+#   our files end-up at
+#       <MYBUCKET>/DUPLICITY/nicepath
+#
+#
+#   Have fun!
+#
+
+
+class IDriveBackend(duplicity.backend.Backend):
+
+    def __init__(self, parsed_url):
+        duplicity.backend.Backend.__init__(self, parsed_url)
+
+        # parsed_url will have leading slashes in it, 4 slashes typically.
+        self.parsed_url = parsed_url
+        self.url_string = duplicity.backend.strip_auth_from_url(self.parsed_url)
+        log.Debug(u"parsed_url: {0}".format(parsed_url))
+
+        self.connected = False
+
+    def user_connected(self):
+        return self.connected
+
+    def request(self, commandline):
+        # request for commands returning data in XML format
+        log.Debug(u"Request command: {0}".format(commandline))
+        try:
+            _, reply, error = self.subprocess_popen(commandline)
+        except KeyError:
+            raise BackendException(u"Unknown protocol failure on request {0}".format(commandline))
+
+        response = reply + error
+        try:
+            xml = u"<root>" + u''.join(re.findall(u"<[^>]+>", response)) + u"</root>"
+            el = ET.fromstring(xml)
+
+        except:
+            el = None
+        log.Debug(u"Request response: {0}".format(response))
+
+        return el
+
+    def connect(self):
+        # get the path to the command executable
+        path = os.environ.get(u"IDEVSPATH")
+        if path is None:
+            log.Warn(u"-" * 72)
+            log.Warn(u"WARNING: No path to 'idevsutil_dedup' has been set. Download module from")
+            log.Warn(u"   https://www.idrivedownloads.com/downloads/linux/download-options/IDrive_linux_64bit.zip")
+            log.Warn(u"or")
+            log.Warn(u"   https://www.idrivedownloads.com/downloads/linux/download-options/IDrive_linux_32bit.zip")
+            log.Warn(u"and place anywhere with exe rights. Then creat env var 'IDEVSPATH' with path to file")
+            log.Warn(u"-" * 72)
+            raise BackendException(u"No IDEVSPATH env var set. Should contain folder to idevsutil_dedup")
+        self.cmd = os.path.join(path, u"idevsutil_dedup")
+        log.Debug(u"IDrive command base: %s" % (self.cmd))
+
+        # get the account-id
+        self.idriveid = os.environ.get(u"IDRIVEID")
+        if self.idriveid is None:
+            log.Warn(u"-" * 72)
+            log.Warn(u"WARNING: IDrive logon ID missing")
+            log.Warn(u"Create an environment variable IDriveID with your IDrive logon ID")
+            log.Warn(u"-" * 72)
+            raise BackendException(u"No IDRIVEID env var set. Should contain IDrive id")
+        log.Debug(u"IDrive id: %s" % (self.idriveid))
+
+        # Get the full-path to the account password file
+        filepath = os.environ.get(u"IDPWDFILE")
+        if filepath is None:
+            log.Warn(u"-" * 72)
+            log.Warn(u"WARNING: IDrive password file missging")
+            log.Warn(u"Please create a file with your IDrive logon password,")
+            log.Warn(u"Then create an environment variable IDPWDFILE with path/filename of said file")
+            log.Warn(u"-" * 72)
+            raise BackendException(u"No IDPWDFILE env var set. Should contain file with password")
+        log.Debug(u"IDrive pwdpath: %s" % (filepath))
+        self.auth_switch = u" --password-file={0}".format(filepath)
+
+        # fakeroot set? Create directory and mark for cleanup
+        if config.fakeroot is None:
+            self.cleanup = False
+            self.fakeroot = u''
+        else:
+            # Make sure fake root is created at root level!
+            self.fakeroot = os.path.join(u'/', config.fakeroot)
+            try:
+                os.mkdir(self.fakeroot)
+            except OSError as e:
+                self.cleanup = False
+                if e.errno == errno.EEXIST:
+                    log.Debug(u"Using existing directory {0} as fake-root".format(self.fakeroot))
+                else:
+                    log.Warn(u"-" * 72)
+                    log.Warn(u"WARNING: Creation of FAKEROOT {0} failed; backup will use system temp directory"
+                             .format(self.fakeroot))
+                    log.Warn(u"This might interfere with incremental backups")
+                    log.Warn(u"-" * 72)
+                    raise BackendException(u"Creation of the directory {0} failed".format(self.fakeroot))
+            else:
+                log.Debug(u"Directory {0} created as fake-root (Will clean-up afterwards!)".format(self.fakeroot))
+                self.cleanup = True
+
+        # get the bucket
+        self.bucket = os.environ.get(u"IDBUCKET")
+        if self.bucket is None:
+            log.Warn(u"-" * 72)
+            log.Warn(u"WARNING: IDrive backup bucket missing")
+            log.Warn(u"Create an environment variable IDBUCKET specifying the target bucket")
+            log.Warn(u"-" * 72)
+            raise BackendException(u"No IDBUCKET env var set. Should contain IDrive backup bucket")
+        log.Debug(u"IDrive bucket: %s" % (self.bucket))
+
+        # check account / get config status and config type
+        el = self.request(self.cmd + self.auth_switch + u" --validate --user={0}".format(self.idriveid)).find(u'tree')
+
+        if el.attrib[u"message"] != u"SUCCESS":
+            raise BackendException(u"Protocol failure - " + el.attrib[u"desc"])
+        if el.attrib[u"desc"] != u"VALID ACCOUNT":
+            raise BackendException(u"IDrive account invalid")
+        if el.attrib[u"configstatus"] != u"SET":
+            raise BackendException(u"IDrive account not set")
+
+        # When private encryption enabled: get the full-path to a encription key file
+        if el.attrib[u"configtype"] == u"PRIVATE":
+            filepath = os.environ.get(u"IDKEYFILE")
+            if filepath is None:
+                log.Warn(u"-" * 72)
+                log.Warn(u"WARNING: IDrive encryption key file missging")
+                log.Warn(u"Please create a file with your IDrive encryption key,")
+                log.Warn(u"Then create an environment variable IDKEYFILE with path/filename of said file")
+                log.Warn(u"-" * 72)
+                raise BackendException(u"No IDKEYFILE env var set. Should contain file with encription key")
+            log.Debug(u"IDrive keypath: %s" % (filepath))
+            self.auth_switch += u" --pvt-key={0}".format(filepath)
+
+        # get the server address
+        el = self.request(self.cmd + self.auth_switch + u" --getServerAddress {0}".format(self.idriveid)).find(u'tree')
+        self.idriveserver = el.attrib[u"cmdUtilityServer"]
+
+        # get the device list - primarely used to get device-id string
+        el = self.request(self.cmd + self.auth_switch + u" --list-device {0}@{1}::home".
+                          format(self.idriveid, self.idriveserver))
+        # scan all returned devices for requested device (== bucket)
+        self.idrivedevid = None
+        for item in el.findall(u'item'):
+            if item.attrib[u'nick_name'] == self.bucket:
+                # prefix and suffix reverse-engineered from Common.pl!
+                self.idrivedevid = u"5c0b" + item.attrib[u"device_id"] + u"4b5z"
+        if self.idrivedevid is None:
+            el = self.request(
+                self.cmd + self.auth_switch +
+                u" --create-bucket --bucket-type=D --nick-name={0} --os=Linux --uid=987654321 {1}@{2}::home/"
+                .format(self.bucket, self.idriveid, self.idriveserver)).find(u'item')
+            # prefix and suffix reverse-engineered from Common.pl!
+            self.idrivedevid = u"5c0b" + el.attrib[u"device_id"] + u"4b5z"
+
+        # We're fully connected!
+        self.connected = True
+        log.Debug(u"User fully connected")
+
+    def list_raw(self):
+        # get raw list; used by _list, _query and _query_list
+        remote_path = os.path.join(urllib.parse.unquote(self.parsed_url.path.lstrip(u'/')),
+                                   self.fakeroot.lstrip(u'/')).rstrip()
+        commandline = ((self.cmd + self.auth_switch + u" --auth-list --device-id={0} {1}@{2}::home/{3}"
+                       .format(self.idrivedevid, self.idriveid, self.idriveserver, remote_path)))
+        try:
+            _, l, _ = self.subprocess_popen(commandline)
+        except:
+            # error: treat as empty response
+            log.Debug(u"list EMPTY response ")
+            return []
+
+        log.Debug(u"list response: {0}".format(l))
+
+        # get a list of lists from data lines returned by idevsutil_dedup --auth-list
+        filtered = map((lambda line: re.split(r"\[|\]", line)), [x for x in l.splitlines() if x.startswith(u"[")])
+        # remove whitespace from elements
+        filtered = map((lambda line: map((lambda c: c.strip()), line)), filtered)
+        # remove empty elements
+        filtered = list(map((lambda cols: list(filter((lambda c: c != u''), cols))), filtered))
+
+        return filtered
+
+    def _put(self, source_path, remote_filename):
+        # Put a file.
+        log.Debug(u"_PUT")
+        if not self.user_connected():
+            self.connect()
+
+        # decode from byte-stream to utf-8 string
+        filename = remote_filename.decode(u'utf-8')
+
+        intrim_file = os.path.join(self.fakeroot, filename)
+        remote_dirpath = urllib.parse.unquote(self.parsed_url.path.lstrip(u'/'))
+
+        os.rename(source_path.name, intrim_file)
+
+        log.Debug(u"put_file: source_path={0}, remote_file={1}".format(source_path.name, filename))
+
+        flist = tempfile.NamedTemporaryFile(u'w')
+        flist.write(intrim_file)
+        flist.seek(0)
+
+        putrequest = ((self.cmd + self.auth_switch + u"  --device-id={0} --files-from={1} / {2}@{3}::home/{4}")
+                      .format(self.idrivedevid, flist.name, self.idriveid, self.idriveserver, remote_dirpath))
+        log.Debug(u"put_file put command: {0}".format(putrequest))
+        _, putresponse, _ = self.subprocess_popen(putrequest)
+        log.Debug(u"put_file put response: {0}".format(putresponse))
+
+        flist.close()
+        os.remove(intrim_file)
+
+    def _get(self, remote_filename, local_path):
+        # Get a file.
+        log.Debug(u"_GET")
+        if not self.user_connected():
+            self.connect()
+
+        # decode from byte-stream to utf-8 string
+        filename = remote_filename.decode(u'utf-8')
+
+        remote_path = os.path.join(urllib.parse.unquote(self.parsed_url.path.lstrip(u'/')),
+                                   self.fakeroot.lstrip(u'/'), filename).rstrip()
+
+        log.Debug(u"_get: remote_filename={0}, local_path={1}, remote_path={2}, parsed_url.path={3}"
+                  .format(filename, local_path, remote_path, self.parsed_url.path))
+
+        # Create tempdir to downlaod file into
+        tmpdir = tempfile.mkdtemp()
+        log.Debug(u"_get created temporary download folder: {}".format(tmpdir))
+
+        # The filelist file
+        flist = tempfile.NamedTemporaryFile(u'w')
+        flist.write(remote_path)
+        flist.seek(0)
+
+        commandline = ((self.cmd + self.auth_switch + u" --device-id={0} --files-from={1} {2}@{3}::home/ {4}")
+                       .format(self.idrivedevid, flist.name, self.idriveid, self.idriveserver, tmpdir))
+        log.Debug(u"get command: {0}".format(commandline))
+        _, getresponse, _ = self.subprocess_popen(commandline)
+        log.Debug(u"_get response: {0}".format(getresponse))
+
+        flist.close()
+
+        # move to the final location
+        downloadedSrcPath = os.path.join(tmpdir, remote_path.lstrip(u'/').rstrip(u'/'))
+        log.Debug(u"_get moving file {0} to final location: {1}".format(downloadedSrcPath, local_path.name))
+
+        os.rename(downloadedSrcPath, local_path.name)
+
+        shutil.rmtree(tmpdir)
+
+    def _list(self):
+        # List files on remote folder
+        log.Debug(u"_LIST")
+        if not self.user_connected():
+            self.connect()
+
+        filtered = self.list_raw()
+        filtered = [x[-1] for x in filtered]
+
+        return filtered
+
+    def _delete(self, remote_filename):
+        # Delete single file
+        log.Debug(u"_DELETE")
+        if not self.user_connected():
+            self.connect()
+
+        # decode from byte-stream to utf-8 string
+        filename = remote_filename.decode(u'utf-8')
+
+        # create a file-list file
+        flist = tempfile.NamedTemporaryFile(u'w')
+        flist.write(filename.lstrip(u'/'))
+        flist.seek(0)
+
+        # target path (remote) on IDrive
+        remote_path = os.path.join(urllib.parse.unquote(self.parsed_url.path.lstrip(u'/')),
+                                   self.fakeroot.lstrip(u'/')).rstrip()
+        log.Debug(u"delete: {0} from remote file path {1}".format(filename, remote_path))
+
+        # delete files from file-list
+        delrequest = ((self.cmd + self.auth_switch +
+                       u" --delete-items --device-id={0} --files-from={1} {2}@{3}::home/{4}")
+                      .format(self.idrivedevid, flist.name, self.idriveid, self.idriveserver, remote_path))
+        log.Debug(u"delete: {0}".format(delrequest))
+        _, delresponse, _ = self.subprocess_popen(delrequest)
+        log.Debug(u"delete response: {0}".format(delresponse))
+
+        # close tempfile
+        flist.close()
+
+    def _delete_list(self, filename_list):
+        # Delete multiple files
+        log.Debug(u"_DELETE LIST")
+        if not self.user_connected():
+            self.connect()
+
+        # create a file-list file
+        flist = tempfile.NamedTemporaryFile(u'w')
+
+        # create file-list
+        for filename in filename_list:
+            flist.write(filename.decode(u'utf-8').lstrip(u'/') + u'\n')
+        flist.seek(0)
+
+        # target path (remote) on IDrive
+        remote_path = os.path.join(urllib.parse.unquote(self.parsed_url.path.lstrip(u'/')),
+                                   self.fakeroot.lstrip(u'/')).rstrip()
+        log.Debug(u"delete multiple files from remote file path {0}".format(remote_path))
+
+        # delete files from file-list
+        delrequest = ((self.cmd + self.auth_switch +
+                       u" --delete-items --device-id={0} --files-from={1} {2}@{3}::home/{4}")
+                      .format(self.idrivedevid, flist.name, self.idriveid, self.idriveserver, remote_path))
+        log.Debug(u"delete: {0}".format(delrequest))
+        _, delresponse, _ = self.subprocess_popen(delrequest)
+        log.Debug(u"delete response: {0}".format(delresponse))
+
+        # close tempfile
+        flist.close()
+
+    def _close(self):
+        # Remove EVS_temp directory + contents
+        log.Debug(u"Removing IDrive temp folder evs_temp")
+        try:
+            shutil.rmtree(u"evs_temp")
+        except:
+            pass
+
+    def _query(self, filename):
+        log.Debug(u"_QUERY")
+        if not self.user_connected():
+            self.connect()
+
+        # Get raw directory list; take-out size (index 1) for requested filename (index -1)
+        filtered = self.list_raw()
+        if filtered:
+            filtered = [x[1] for x in filtered if x[-1] == filename.decode(u'utf-8')]
+        if filtered:
+            return {u'size': int(filtered[0])}
+
+        return {u'size': -1}
+
+    def _query_list(self, filename_list):
+        log.Debug(u"_QUERY_LIST")
+        if not self.user_connected():
+            self.connect()
+
+        # Get raw directory list
+        filtered = self.list_raw()
+
+        # For each filename in list: take-out size (index 1) for requested filename (index -1)
+        info = {}
+        for filename in filename_list:
+            if filtered:
+                result = [x[1] for x in filtered if x[-1] == filename.decode(u'utf-8')]
+            if result:
+                info[filename] = {u'size': int(result[0])}
+            else:
+                info[filename] = {u'size': -1}
+
+        return info
+
+    def __del__(self):
+        # remove the self-created temp dir.
+        # We do it here, AFTER the clean-up of Duplicity, so it will be empty!
+        if self.cleanup:
+            os.rmdir(self.fakeroot)
+
+
+duplicity.backend.register_backend(u"idrived", IDriveBackend)
diff -Nru duplicity-0.8.18/duplicity/backends/localbackend.py duplicity-0.8.19/duplicity/backends/localbackend.py
--- duplicity-0.8.18/duplicity/backends/localbackend.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/duplicity/backends/localbackend.py	2021-04-29 18:20:20.000000000 +0000
@@ -22,7 +22,7 @@
 import os
 
 import duplicity.backend
-from duplicity import path
+from duplicity import path, progress
 from duplicity.errors import BackendException
 
 
@@ -54,7 +54,11 @@
 
     def _put(self, source_path, remote_filename):
         target_path = self.remote_pathdir.append(remote_filename)
+        source_path.setdata()
+        source_size = source_path.getsize()
+        progress.report_transfer(0, source_size)
         target_path.writefileobj(source_path.open(u"rb"))
+        progress.report_transfer(source_size, source_size)
 
     def _get(self, filename, local_path):
         source_path = self.remote_pathdir.append(filename)
diff -Nru duplicity-0.8.18/duplicity/backends/mediafirebackend.py duplicity-0.8.19/duplicity/backends/mediafirebackend.py
--- duplicity-0.8.18/duplicity/backends/mediafirebackend.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/duplicity/backends/mediafirebackend.py	2021-04-29 18:20:20.000000000 +0000
@@ -111,7 +111,7 @@
     def _delete(self, filename):
         u"""Delete single file"""
         uri = self._build_uri(filename)
-        self.client.delete_file(uri)
+        self.client.delete_file(uri, purge=config.mf_purge)
 
     def _delete_list(self, filename_list):
         u"""Delete list of files"""
diff -Nru duplicity-0.8.18/duplicity/backends/megav3backend.py duplicity-0.8.19/duplicity/backends/megav3backend.py
--- duplicity-0.8.18/duplicity/backends/megav3backend.py	1970-01-01 00:00:00.000000000 +0000
+++ duplicity-0.8.19/duplicity/backends/megav3backend.py	2021-04-29 18:20:20.000000000 +0000
@@ -0,0 +1,280 @@
+# -*- Mode:Python; indent-tabs-mode:nil; tab-width:4; encoding:utf8 -*-
+#
+# Copyright 2020 Jose L. Domingo Lopez <github@24x7linux.com>
+#
+# This file is part of duplicity.
+#
+# Duplicity is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the
+# Free Software Foundation; either version 2 of the License, or (at your
+# option) any later version.
+#
+# Duplicity is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with duplicity; if not, write to the Free Software Foundation,
+# Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+from __future__ import print_function
+
+import os
+import re
+import subprocess
+
+import duplicity.backend
+from duplicity import util
+from duplicity.errors import BackendException
+from future import standard_library
+
+standard_library.install_aliases()
+
+
+class Megav3Backend(duplicity.backend.Backend):
+    u"""Backend for MEGA.nz cloud storage, only one that works for accounts created since Nov. 2018
+    See https://github.com/megous/megatools/issues/411 for more details
+
+    This MEGA backend resorts to official tools (MEGAcmd) as available at https://mega.nz/cmd
+    MEGAcmd works through a single binary called "mega-cmd", which keeps state (for example,
+    persisting a session). Multiple "mega-*" shell wrappers (ie. "mega-ls") exist as the user
+    interface to "mega-cmd" and MEGA API
+    The full MEGAcmd User Guide can be found in the software's GitHub page below :
+    https://github.com/meganz/MEGAcmd/blob/master/UserGuide.md"""
+
+    def __init__(self, parsed_url):
+        duplicity.backend.Backend.__init__(self, parsed_url)
+
+        # Sanity check : ensure all the necessary "MEGAcmd" binaries exist
+        self._check_binary_exists(u'mega-cmd')
+        self._check_binary_exists(u'mega-exec')
+        self._check_binary_exists(u'mega-help')
+        self._check_binary_exists(u'mega-get')
+        self._check_binary_exists(u'mega-login')
+        self._check_binary_exists(u'mega-logout')
+        self._check_binary_exists(u'mega-ls')
+        self._check_binary_exists(u'mega-mkdir')
+        self._check_binary_exists(u'mega-put')
+        self._check_binary_exists(u'mega-rm')
+        self._check_binary_exists(u'mega-whoami')
+
+        # "MEGAcmd" does not use a config file, however it is handy to keep one (with the old ".megarc" format) to
+        # securely store the username and password
+        self._hostname = parsed_url.hostname
+        if parsed_url.username is None:
+            self._megarc = os.getenv(u'HOME') + u'/.megav3rc'
+            try:
+                conf_file = open(self._megarc, u"r")
+            except Exception as e:
+                raise BackendException(
+                    u"No password provided in URL and MEGA configuration "
+                    u"file for duplicity does not exist as '%s'"
+                    % (self._megarc,)
+                )
+
+            myvars = {}
+            for line in conf_file:
+                name, var = line.partition(u"=")[::2]
+                myvars[name.strip()] = str(var.strip())
+            conf_file.close()
+            self._username = myvars[u"Username"]
+            self._password = myvars[u"Password"]
+
+        else:
+            self._username = parsed_url.username
+            self._password = parsed_url.password
+
+        no_logout_option = parsed_url.query_args.get(u'no_logout', [])
+        self._no_logout = (len(no_logout_option) > 0) and (
+            no_logout_option[0].lower() in [u'1', u'yes', u'true']
+        )
+
+        self.ensure_mega_cmd_running()
+
+        # Remote folder ("MEGAcmd" no longer shows "Root/" at the top of the hierarchy)
+        self._folder = u'/' + parsed_url.path[1:]
+
+        # Only create the remote folder if it doesn't exist yet
+        self.mega_login()
+        cmd = [u'mega-ls', self._folder]
+        try:
+            self.subprocess_popen(cmd)
+        except Exception as e:
+            self._makedir(self._folder)
+
+    def _check_binary_exists(self, cmd):
+        u'Checks that a specified command exists in the running user command path'
+
+        try:
+            # Ignore the output, as we only need the return code
+            subprocess.check_output([u'which', cmd])
+        except Exception as e:
+            raise BackendException(
+                u"Command '%s' not found, make sure 'MEGAcmd' tools (https://mega.nz/cmd) is "
+                u"properly installed and in the running user command path"
+                % (cmd,)
+            )
+
+    def ensure_mega_cmd_running(self):
+        u'Trigger any mega command to ensure mega-cmd server is running'
+        try:
+            subprocess.run(
+                u"mega-help",
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            ).check_returncode()
+        except Exception:
+            raise BackendException(u'Cannot execute mega command')
+
+    def _makedir(self, path):
+        u'Creates a remote directory (recursively if necessary)'
+
+        self.mega_login()
+        cmd = [u'mega-mkdir', u'-p', path]
+        try:
+            self.subprocess_popen(cmd)
+        except Exception as e:
+            error_str = str(e)
+            if u"Folder already exists" in error_str:
+                raise BackendException(
+                    u"Folder '%s' could not be created on MEGA because it already exists. "
+                    u"Use another path or remove the folder in MEGA manually"
+                    % (path,)
+                )
+            else:
+                raise BackendException(
+                    u"Folder '%s' could not be created, reason : '%s'"
+                    % (path, e)
+                )
+
+    def _put(self, source_path, remote_filename):
+        u"""Uploads file to the specified remote folder (tries to delete it first to make
+        sure the new one can be uploaded)"""
+
+        try:
+            self.delete(remote_filename.decode())
+        except Exception:
+            pass
+        self.upload(
+            local_file=source_path.get_canonical().decode(),
+            remote_file=remote_filename.decode(),
+        )
+
+    def _get(self, remote_filename, local_path):
+        u'Downloads file from the specified remote path'
+
+        self.download(
+            remote_file=remote_filename.decode(),
+            local_file=local_path.name.decode(),
+        )
+
+    def _list(self):
+        u'Lists files in the specified remote path'
+
+        return self.folder_contents(files_only=True)
+
+    def _delete(self, filename):
+        u'Deletes file from the specified remote path'
+
+        self.delete(remote_file=filename.decode())
+
+    def _close(self):
+        u'Function called when backend is done being used'
+
+        if not self._no_logout:
+            cmd = [u'mega-logout']
+            self.subprocess_popen(cmd)
+
+        cmd = [u'mega-exec', u'exit']
+        self.subprocess_popen(cmd)
+
+    def mega_login(self):
+        u"""Helper function to check existing session exists"""
+
+        # Abort if command doesn't return in a reasonable time (somehow "mega-session" sometimes
+        # doesn't return), and create session if one doesn't exist yet
+        try:
+            result = subprocess.run(
+                u'mega-whoami',
+                timeout=30,
+                capture_output=True,
+            )
+            result.check_returncode()
+            current_username = result.stdout.decode().split(u':')[-1].strip()
+            if current_username != self._username:
+                raise Exception(u"Username is not match")
+        except subprocess.TimeoutExpired:
+            self._close()
+            raise BackendException(
+                u"Timed out while trying to determine if a MEGA session exists"
+            )
+        except Exception as e:
+            if self._password is None:
+                self._password = self.get_password()
+
+            cmd = [u'mega-login', self._username, self._password]
+            try:
+                subprocess.run(
+                    cmd,
+                    stderr=subprocess.DEVNULL,
+                ).check_returncode()
+            except Exception as e:
+                self._close()
+                raise BackendException(
+                    u"Could not log in to MEGA, error : '%s'" % (e,)
+                )
+
+    def folder_contents(self, files_only=False):
+        u'Lists contents of a remote MEGA path, optionally ignoring subdirectories'
+
+        cmd = [u'mega-ls', u'-l', self._folder]
+
+        self.mega_login()
+        files = subprocess.check_output(cmd)
+        files = files.decode().split(u'\n')
+
+        # Optionally ignore directories
+        if files_only:
+            files = [f.split()[5] for f in files if re.search(u'^-', f)]
+
+        return files
+
+    def download(self, remote_file, local_file):
+        u'Downloads a file from a remote MEGA path'
+
+        cmd = [u'mega-get', self._folder + u'/' + remote_file, local_file]
+        self.mega_login()
+        self.subprocess_popen(cmd)
+
+    def upload(self, local_file, remote_file):
+        u'Uploads a file to a remote MEGA path'
+
+        cmd = [u'mega-put', local_file, self._folder + u'/' + remote_file]
+        self.mega_login()
+        try:
+            self.subprocess_popen(cmd)
+        except Exception as e:
+            error_str = str(e)
+            if u"Reached storage quota" in error_str:
+                raise BackendException(
+                    u"MEGA account over quota, could not write file : '%s' . "
+                    u"Upgrade your storage at https://mega.nz/pro or remove some data."
+                    % (remote_file,)
+                )
+            else:
+                raise BackendException(
+                    u"Failed writing file '%s' to MEGA, reason : '%s'"
+                    % (remote_file, e)
+                )
+
+    def delete(self, remote_file):
+        u'Deletes a file from a remote MEGA path'
+
+        cmd = [u'mega-rm', u'-f', self._folder + u'/' + remote_file]
+        self.mega_login()
+        self.subprocess_popen(cmd)
+
+
+duplicity.backend.register_backend(u'megav3', Megav3Backend)
+duplicity.backend.uses_netloc.extend([u'megav3'])
diff -Nru duplicity-0.8.18/duplicity/backends/multibackend.py duplicity-0.8.19/duplicity/backends/multibackend.py
--- duplicity-0.8.18/duplicity/backends/multibackend.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/duplicity/backends/multibackend.py	2021-04-29 18:20:20.000000000 +0000
@@ -206,10 +206,10 @@
                 for prefix in config[u'prefixes']:
                     log.Log(_(u"Multibackend: register affinity for prefix %s")
                             % prefix, log.INFO)
-                if prefix in self.__affinities:
-                    self.__affinities[prefix].append(store)
-                else:
-                    self.__affinities[prefix] = [store]
+                    if prefix in self.__affinities:
+                        self.__affinities[prefix].append(store)
+                    else:
+                        self.__affinities[prefix] = [store]
 
             # store_list = store.list()
             # log.Log(_("MultiBackend: at init, store %s has %s files")
@@ -342,9 +342,6 @@
                 # In stripe mode, only one item will have the file
                 if self.__mode == u'stripe':
                     return
-            log.Log(_(u"MultiBackend: failed to delete %s from %s")
-                    % (filename, s.backend.parsed_url.url_string),
-                    log.INFO)
         if not passed:
             log.Log(_(u"MultiBackend: failed to delete %s. Tried all backing stores and none succeeded")
                     % (filename),
diff -Nru duplicity-0.8.18/duplicity/backends/onedrivebackend.py duplicity-0.8.19/duplicity/backends/onedrivebackend.py
--- duplicity-0.8.18/duplicity/backends/onedrivebackend.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/duplicity/backends/onedrivebackend.py	2021-04-29 18:20:20.000000000 +0000
@@ -48,16 +48,51 @@
 class OneDriveBackend(duplicity.backend.Backend):
     u"""Uses Microsoft OneDrive (formerly SkyDrive) for backups."""
 
+    OAUTH_TOKEN_PATH = os.path.expanduser(
+        u'~/.duplicity_onedrive_oauthtoken.json')
+
     API_URI = u'https://graph.microsoft.com/v1.0/'
     # The large file upload API says that uploaded chunks (except the last) must be multiples of 327680 bytes.
     REQUIRED_FRAGMENT_SIZE_MULTIPLE = 327680
+    CLIENT_ID = u'000000004C12E85D'
+    OAUTH_TOKEN_URI = u'https://login.live.com/oauth20_token.srf'
+    OAUTH_AUTHORIZE_URI = u'https://login.live.com/oauth20_authorize.srf'
+    OAUTH_REDIRECT_URI = u'https://login.live.com/oauth20_desktop.srf'
+    # Files.Read is for reading files,
+    # Files.ReadWrite  is for creating/writing files,
+    # User.Read is needed for the /me request to see if the token works.
+    # offline_access is necessary for duplicity to access onedrive without
+    # the user being logged in right now.
+    OAUTH_SCOPE = [u'Files.Read', u'Files.ReadWrite', u'User.Read', u'offline_access']
+
+    # OAUTHLIB_RELAX_TOKEN_SCOPE prevents the oauthlib from complaining about a mismatch between
+    # the requested scope and the delivered scope. We need this because we don't get a refresh
+    # token without asking for offline_access, but Microsoft Graph doesn't include offline_access
+    # in its response (even though it does send a refresh_token).
+
+    os.environ[u'OAUTHLIB_RELAX_TOKEN_SCOPE'] = u'TRUE'
 
     def __init__(self, parsed_url):
         duplicity.backend.Backend.__init__(self, parsed_url)
 
+        # Import requests and requests-oauthlib
+        try:
+            # On debian (and derivatives), get these dependencies using:
+            # apt-get install python-requests python-requests-oauthlib
+            # On fedora (and derivatives), get these dependencies using:
+            # yum install python-requests python-requests-oauthlib
+            global requests
+            global OAuth2Session
+            import requests
+            from requests_oauthlib import OAuth2Session
+        except ImportError as e:
+            raise BackendException((
+                u'OneDrive backend requires python-requests and '
+                u'python-requests-oauthlib to be installed. Please install '
+                u'them and try again.\n' + str(e)))
+
         self.directory = parsed_url.path.lstrip(u'/')
-        onedrive_root = os.environ.get(u'ONEDRIVE_ROOT', u'me/drive/root')
-        self.directory_onedrive_path = u'%s:/%s/' % (onedrive_root, self.directory)
+        self.directory_onedrive_path = u'me/drive/root:/%s/' % self.directory
         if self.directory == u"":
             raise BackendException((
                 u'You did not specify a path. '
@@ -71,17 +106,85 @@
         self.initialize_oauth2_session()
 
     def initialize_oauth2_session(self):
-        client_id = os.environ.get(u'OAUTH2_CLIENT_ID')
-        refresh_token = os.environ.get(u'OAUTH2_REFRESH_TOKEN')
-        if client_id and refresh_token:
-            self.http_client = ExternalOAuth2Session(client_id, refresh_token)
-        else:
-            self.http_client = DefaultOAuth2Session(self.API_URI)
+        def token_updater(token):
+            try:
+                with open(self.OAUTH_TOKEN_PATH, u'w') as f:
+                    json.dump(token, f)
+            except Exception as e:
+                log.Error((u'Could not save the OAuth2 token to %s. '
+                           u'This means you may need to do the OAuth2 '
+                           u'authorization process again soon. '
+                           u'Original error: %s' % (
+                               self.OAUTH_TOKEN_PATH, e)))
+
+        token = None
+        try:
+            with open(self.OAUTH_TOKEN_PATH) as f:
+                token = json.load(f)
+        except IOError as e:
+            log.Error((u'Could not load OAuth2 token. '
+                       u'Trying to create a new one. (original error: %s)' % e))
+
+        self.http_client = OAuth2Session(
+            self.CLIENT_ID,
+            scope=self.OAUTH_SCOPE,
+            redirect_uri=self.OAUTH_REDIRECT_URI,
+            token=token,
+            auto_refresh_kwargs={
+                u'client_id': self.CLIENT_ID,
+            },
+            auto_refresh_url=self.OAUTH_TOKEN_URI,
+            token_updater=token_updater)
+
+        # We have to refresh token manually because it's not working "under the covers"
+        if token is not None:
+            self.http_client.refresh_token(self.OAUTH_TOKEN_URI)
+
+        # Send a request to make sure the token is valid (or could at least be
+        # refreshed successfully, which will happen under the covers). In case
+        # this request fails, the provided token was too old (i.e. expired),
+        # and we need to get a new token.
+        user_info_response = self.http_client.get(self.API_URI + u'me')
+        if user_info_response.status_code != requests.codes.ok:
+            token = None
+
+        if token is None:
+            if not sys.stdout.isatty() or not sys.stdin.isatty():
+                log.FatalError((u'The OAuth2 token could not be loaded from %s '
+                                u'and you are not running duplicity '
+                                u'interactively, so duplicity cannot possibly '
+                                u'access OneDrive.' % self.OAUTH_TOKEN_PATH))
+            authorization_url, state = self.http_client.authorization_url(
+                self.OAUTH_AUTHORIZE_URI, display=u'touch')
+
+            print()
+            print(u'In order to authorize duplicity to access your OneDrive, '
+                  u'please open %s in a browser and copy the URL of the blank '
+                  u'page the dialog leads to.' % authorization_url)
+            print()
+
+            redirected_to = input(u'URL of the blank page: ').strip()
+
+            token = self.http_client.fetch_token(
+                self.OAUTH_TOKEN_URI,
+                authorization_response=redirected_to)
+
+            user_info_response = self.http_client.get(self.API_URI + u'me')
+            user_info_response.raise_for_status()
+
+            try:
+                with open(self.OAUTH_TOKEN_PATH, u'w') as f:
+                    json.dump(token, f)
+            except Exception as e:
+                log.Error((u'Could not save the OAuth2 token to %s. '
+                           u'This means you need to do the OAuth2 authorization '
+                           u'process on every start of duplicity. '
+                           u'Original error: %s' % (
+                               self.OAUTH_TOKEN_PATH, e)))
 
     def _list(self):
         accum = []
-        # Strip last slash, because graph can give a 404 in some cases with it
-        next_url = self.API_URI + self.directory_onedrive_path.rstrip(u'/') + u':/children'
+        next_url = self.API_URI + self.directory_onedrive_path + u':/children'
         while True:
             response = self.http_client.get(next_url)
             if response.status_code == 404:
@@ -193,163 +296,4 @@
         self.initialize_oauth2_session()
 
 
-class OneDriveOAuth2Session(object):
-    u"""A tiny wrapper for OAuth2Session that handles some OneDrive details."""
-
-    OAUTH_TOKEN_URI = u'https://login.live.com/oauth20_token.srf'
-
-    def __init__(self):
-        # OAUTHLIB_RELAX_TOKEN_SCOPE prevents the oauthlib from complaining
-        # about a mismatch between the requested scope and the delivered scope.
-        # We need this because we don't get a refresh token without asking for
-        # offline_access, but Microsoft Graph doesn't include offline_access
-        # in its response (even though it does send a refresh_token).
-        os.environ[u'OAUTHLIB_RELAX_TOKEN_SCOPE'] = u'TRUE'
-
-        # Import requests-oauthlib
-        try:
-            # On debian (and derivatives), get these dependencies using:
-            # apt-get install python-requests-oauthlib
-            # On fedora (and derivatives), get these dependencies using:
-            # yum install python-requests-oauthlib
-            from requests_oauthlib import OAuth2Session
-            self.session_class = OAuth2Session
-        except ImportError as e:
-            raise BackendException((
-                u'OneDrive backend requires python-requests-oauthlib to be '
-                u'installed. Please install it and try again.\n' + str(e)))
-
-        # Should be filled by a subclass
-        self.session = None
-
-    def get(self, *args, **kwargs):
-        return self.session.get(*args, **kwargs)
-
-    def put(self, *args, **kwargs):
-        return self.session.put(*args, **kwargs)
-
-    def post(self, *args, **kwargs):
-        return self.session.post(*args, **kwargs)
-
-    def delete(self, *args, **kwargs):
-        return self.session.delete(*args, **kwargs)
-
-
-class DefaultOAuth2Session(OneDriveOAuth2Session):
-    u"""A possibly-interactive console session using a built-in API key"""
-
-    OAUTH_TOKEN_PATH = os.path.expanduser(
-        u'~/.duplicity_onedrive_oauthtoken.json')
-    CLIENT_ID = u'000000004C12E85D'
-    OAUTH_AUTHORIZE_URI = u'https://login.live.com/oauth20_authorize.srf'
-    OAUTH_REDIRECT_URI = u'https://login.live.com/oauth20_desktop.srf'
-    # Files.Read is for reading files,
-    # Files.ReadWrite  is for creating/writing files,
-    # User.Read is needed for the /me request to see if the token works.
-    # offline_access is necessary for duplicity to access onedrive without
-    # the user being logged in right now.
-    OAUTH_SCOPE = [u'Files.Read', u'Files.ReadWrite', u'User.Read', u'offline_access']
-
-    def __init__(self, api_uri):
-        super(DefaultOAuth2Session, self).__init__()
-
-        token = None
-        try:
-            with open(self.OAUTH_TOKEN_PATH) as f:
-                token = json.load(f)
-        except IOError as e:
-            log.Error((u'Could not load OAuth2 token. '
-                       u'Trying to create a new one. (original error: %s)' % e))
-
-        self.session = self.session_class(
-            self.CLIENT_ID,
-            scope=self.OAUTH_SCOPE,
-            redirect_uri=self.OAUTH_REDIRECT_URI,
-            token=token,
-            auto_refresh_kwargs={
-                u'client_id': self.CLIENT_ID,
-            },
-            auto_refresh_url=self.OAUTH_TOKEN_URI,
-            token_updater=self.token_updater)
-
-        # We have to refresh token manually because it's not working "under the covers"
-        if token is not None:
-            self.session.refresh_token(self.OAUTH_TOKEN_URI)
-
-        # Send a request to make sure the token is valid (or could at least be
-        # refreshed successfully, which will happen under the covers). In case
-        # this request fails, the provided token was too old (i.e. expired),
-        # and we need to get a new token.
-        user_info_response = self.session.get(api_uri + u'me')
-        if user_info_response.status_code != 200:
-            token = None
-
-        if token is None:
-            if not sys.stdout.isatty() or not sys.stdin.isatty():
-                log.FatalError((u'The OAuth2 token could not be loaded from %s '
-                                u'and you are not running duplicity '
-                                u'interactively, so duplicity cannot possibly '
-                                u'access OneDrive.' % self.OAUTH_TOKEN_PATH))
-            authorization_url, state = self.session.authorization_url(
-                self.OAUTH_AUTHORIZE_URI, display=u'touch')
-
-            print()
-            print(u'In order to authorize duplicity to access your OneDrive, '
-                  u'please open %s in a browser and copy the URL of the blank '
-                  u'page the dialog leads to.' % authorization_url)
-            print()
-
-            redirected_to = input(u'URL of the blank page: ').strip()
-
-            token = self.session.fetch_token(
-                self.OAUTH_TOKEN_URI,
-                authorization_response=redirected_to)
-
-            user_info_response = self.session.get(api_uri + u'me')
-            user_info_response.raise_for_status()
-
-            try:
-                with open(self.OAUTH_TOKEN_PATH, u'w') as f:
-                    json.dump(token, f)
-            except Exception as e:
-                log.Error((u'Could not save the OAuth2 token to %s. '
-                           u'This means you need to do the OAuth2 authorization '
-                           u'process on every start of duplicity. '
-                           u'Original error: %s' % (
-                               self.OAUTH_TOKEN_PATH, e)))
-
-    def token_updater(self, token):
-        try:
-            with open(self.OAUTH_TOKEN_PATH, u'w') as f:
-                json.dump(token, f)
-        except Exception as e:
-            log.Error((u'Could not save the OAuth2 token to %s. '
-                       u'This means you may need to do the OAuth2 '
-                       u'authorization process again soon. '
-                       u'Original error: %s' % (
-                           self.OAUTH_TOKEN_PATH, e)))
-
-
-class ExternalOAuth2Session(OneDriveOAuth2Session):
-    u"""Caller is managing tokens and provides an active refresh token."""
-    def __init__(self, client_id, refresh_token):
-        super(ExternalOAuth2Session, self).__init__()
-
-        token = {
-            u'refresh_token': refresh_token,
-        }
-
-        self.session = self.session_class(
-            client_id,
-            token=token,
-            auto_refresh_kwargs={
-                u'client_id': client_id,
-            },
-            auto_refresh_url=self.OAUTH_TOKEN_URI)
-
-        # Get an initial refresh under our belts, since we don't have an access
-        # token to start with.
-        self.session.refresh_token(self.OAUTH_TOKEN_URI)
-
-
 duplicity.backend.register_backend(u'onedrive', OneDriveBackend)
diff -Nru duplicity-0.8.18/duplicity/backends/pydrivebackend.py duplicity-0.8.19/duplicity/backends/pydrivebackend.py
--- duplicity-0.8.18/duplicity/backends/pydrivebackend.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/duplicity/backends/pydrivebackend.py	2021-04-29 18:20:20.000000000 +0000
@@ -87,13 +87,13 @@
                 credentials = ServiceAccountCredentials(parsed_url.username + u'@' + parsed_url.hostname, signer,
                                                         scopes=u'https://www.googleapis.com/auth/drive')
             credentials.authorize(httplib2.Http())
-            gauth = GoogleAuth()
+            gauth = GoogleAuth(http_timeout=60)
             gauth.credentials = credentials
         elif u'GOOGLE_DRIVE_SETTINGS' in os.environ:
-            gauth = GoogleAuth(settings_file=os.environ[u'GOOGLE_DRIVE_SETTINGS'])
+            gauth = GoogleAuth(settings_file=os.environ[u'GOOGLE_DRIVE_SETTINGS'], http_timeout=60)
             gauth.CommandLineAuth()
         elif (u'GOOGLE_SECRETS_FILE' in os.environ and u'GOOGLE_CREDENTIALS_FILE' in os.environ):
-            gauth = GoogleAuth()
+            gauth = GoogleAuth(http_timeout=60)
             gauth.LoadClientConfigFile(os.environ[u'GOOGLE_SECRETS_FILE'])
             gauth.LoadCredentialsFile(os.environ[u'GOOGLE_CREDENTIALS_FILE'])
             if gauth.credentials is None:
diff -Nru duplicity-0.8.18/duplicity/backends/ssh_paramiko_backend.py duplicity-0.8.19/duplicity/backends/ssh_paramiko_backend.py
--- duplicity-0.8.18/duplicity/backends/ssh_paramiko_backend.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/duplicity/backends/ssh_paramiko_backend.py	2021-04-29 18:20:20.000000000 +0000
@@ -206,7 +206,7 @@
                       config.ssh_options)
         if (m is not None):
             keyfilename = m.group(3) if m.group(3) else m.group(1)
-            self.config[u'identityfile'] = keyfilename
+            self.config[u'identityfile'] = keyfilename.strip(u'\'\"')
         # ensure ~ is expanded and identity exists in dictionary
         if u'identityfile' in self.config:
             if not isinstance(self.config[u'identityfile'], list):
diff -Nru duplicity-0.8.18/duplicity/backends/sxbackend.py duplicity-0.8.19/duplicity/backends/sxbackend.py
--- duplicity-0.8.18/duplicity/backends/sxbackend.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/duplicity/backends/sxbackend.py	2021-04-29 18:20:20.000000000 +0000
@@ -43,7 +43,7 @@
 
     def _list(self):
         # Do a long listing to avoid connection reset
-        commandline = u"sxls {0}".format(self.url_string)
+        commandline = u"sxls {0}/".format(self.url_string)
         _, l, _ = self.subprocess_popen(commandline)
         # Look for our files as the last element of a long list line
         return [util.fsencode(x[x.rindex(u'/') + 1:].split()[-1]) for x in l.split(u'\n')
diff -Nru duplicity-0.8.18/duplicity/commandline.py duplicity-0.8.19/duplicity/commandline.py
--- duplicity-0.8.18/duplicity/commandline.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/duplicity/commandline.py	2021-04-29 18:20:20.000000000 +0000
@@ -389,6 +389,9 @@
                       dest=u"", action=u"callback",
                       callback=lambda o, s, v, p: config.gpg_profile.hidden_recipients.append(v))
 
+    # Fake-root for iDrived backend
+    parser.add_option(u"--idr-fakeroot", dest=u"fakeroot", type=u"file", metavar=_(u"path"))
+
     # ignore (some) errors during operations; supposed to make it more
     # likely that you are able to restore data under problematic
     # circumstances. the default should absolutely always be False unless
@@ -650,6 +653,9 @@
 
     parser.add_option(u"-V", u"--version", action=u"callback", callback=print_ver)
 
+    # option for mediafire to purge files on delete instead of sending to trash
+    parser.add_option(u"--mf-purge", action=u"store_true")
+
     # volume size
     # TRANSL: Used in usage help to represent a desired number of
     # something. Example:
@@ -1002,12 +1008,14 @@
   full <%(source_dir)s> <%(target_url)s>
   incr <%(source_dir)s> <%(target_url)s>
   list-current-files <%(target_url)s>
-  restore <%(source_url)s> <%(target_dir)s>
-  remove-older-than <%(time)s> <%(target_url)s>
   remove-all-but-n-full <%(count)s> <%(target_url)s>
   remove-all-inc-of-but-n-full <%(count)s> <%(target_url)s>
+  remove-older-than <%(time)s> <%(target_url)s>
+  replicate <%(source_url)s> <%(target_url)s>
+  restore <%(source_url)s> <%(target_dir)s>
   verify <%(target_url)s> <%(source_dir)s>
-  replicate <%(source_url)s> <%(target_url)s>""" % trans
+
+""" % trans
 
     return msg
 
diff -Nru duplicity-0.8.18/duplicity/config.py duplicity-0.8.19/duplicity/config.py
--- duplicity-0.8.18/duplicity/config.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/duplicity/config.py	2021-04-29 18:20:20.000000000 +0000
@@ -362,6 +362,12 @@
 # delay (in seconds) before next operation after failure
 backend_retry_delay = 30
 
+# option for mediafire to purge files on delete instead of sending to trash
+mf_purge = False
+
+# Fake root directory path for iDrived backend
+fakeroot = None
+
 # default filesystem encoding
 # In Python 2 it seems that sys.getfilesystemencoding() will normally return
 # 'utf-8' or some other sane encoding, but will sometimes fail and return
diff -Nru duplicity-0.8.18/duplicity/dup_collections.py duplicity-0.8.19/duplicity/dup_collections.py
--- duplicity-0.8.18/duplicity/dup_collections.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/duplicity/dup_collections.py	2021-04-29 18:20:20.000000000 +0000
@@ -145,8 +145,11 @@
         u"""
         Add local and remote manifest filenames to backup set
         """
-        assert not self.remote_manifest_name, (self.remote_manifest_name,
-                                               remote_filename)
+        assert not self.remote_manifest_name, \
+            u"Cannot set filename of remote manifest to %s; already set to %s." % (
+                remote_filename,
+                self.remote_manifest_name,
+            )
         self.remote_manifest_name = remote_filename
 
         if self.action != u"replicate":
@@ -905,7 +908,7 @@
                 time_set_pairs.append((set.time, set))
             else:
                 time_set_pairs.append((set.end_time, set))
-        time_set_pairs.sort()
+        time_set_pairs.sort(key=lambda x: x[0])
         return ([p[1] for p in time_set_pairs], incomplete_sets)
 
     def get_signature_chains(self, local, filelist=None):
diff -Nru duplicity-0.8.18/duplicity/dup_main.py duplicity-0.8.19/duplicity/dup_main.py
--- duplicity-0.8.18/duplicity/dup_main.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/duplicity/dup_main.py	2021-04-29 18:20:20.000000000 +0000
@@ -174,14 +174,14 @@
                     if use_cache and config.gpg_profile.passphrase:
                         pass1 = config.gpg_profile.passphrase
                     else:
-                        pass1 = getpass_safe(_(u"GnuPG passphrase:") + u" ")
+                        pass1 = getpass_safe(_(u"GnuPG passphrase for decryption:") + u" ")
 
             if n == 1:
                 pass2 = pass1
             elif for_signing:
                 pass2 = getpass_safe(_(u"Retype passphrase for signing key to confirm: "))
             else:
-                pass2 = getpass_safe(_(u"Retype passphrase to confirm: "))
+                pass2 = getpass_safe(_(u"Retype passphrase for decryption to confirm: "))
 
             if not pass1 == pass2:
                 log.Log(_(u"First and second passphrases do not match!  Please try again."),
@@ -712,6 +712,8 @@
     @return: void
     """
     if config.dry_run:
+        # Only prints list of required volumes when running dry
+        restore_get_patched_rop_iter(col_stats)
         return
     if not patchdir.Write_ROPaths(config.local_path,
                                   restore_get_patched_rop_iter(col_stats)):
@@ -760,14 +762,19 @@
             log.Progress(_(u'Processed volume %d of %d') % (cur_vol[0], num_vols),
                          cur_vol[0], num_vols)
 
-    if hasattr(config.backend, u'pre_process_download'):
+    if hasattr(config.backend, u'pre_process_download') or config.dry_run:
         file_names = []
         for backup_set in backup_setlist:
             manifest = backup_set.get_manifest()
             volumes = manifest.get_containing_volumes(index)
             for vol_num in volumes:
                 file_names.append(backup_set.volume_name_dict[vol_num])
-        config.backend.pre_process_download(file_names)
+        if config.dry_run:
+            log.Notice(u"Required volumes to restore:\n\t" +
+                       u'\n\t'.join(file_name.decode() for file_name in file_names))
+            return None
+        else:
+            config.backend.pre_process_download(file_names)
 
     fileobj_iters = list(map(get_fileobj_iter, backup_setlist))
     tarfiles = list(map(patchdir.TarFile_FromFileobjs, fileobj_iters))
@@ -1557,7 +1564,12 @@
                                                   action).set_values()
 
     # check archive synch with remote, fix if needed
-    if action not in [u"collection-status", u"replicate"]:
+    if action not in [u"collection-status",
+                      u"remove-all-but-n-full",
+                      u"remove-all-inc-of-but-n-full",
+                      u"remove-old",
+                      u"replicate",
+                      ]:
         sync_archive(col_stats)
 
     while True:
diff -Nru duplicity-0.8.18/duplicity/log.py duplicity-0.8.19/duplicity/log.py
--- duplicity-0.8.18/duplicity/log.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/duplicity/log.py	2021-04-29 18:20:20.000000000 +0000
@@ -68,7 +68,7 @@
         return u"ERROR"
 
 
-def Log(s, verb_level, code=1, extra=None, force_print=False):
+def Log(s, verb_level, code=1, extra=None, force_print=False, transfer_progress=False):
     u"""Write s to stderr if verbosity level low enough"""
     global _logger
     if extra:
@@ -91,7 +91,8 @@
 
     _logger.log(DupToLoggerLevel(verb_level), s,
                 extra={u'levelName': LevelName(verb_level),
-                       u'controlLine': controlLine})
+                       u'controlLine': controlLine,
+                       u'transferProgress': transfer_progress})
 
     if force_print:
         _logger.setLevel(initial_level)
@@ -215,7 +216,7 @@
                                                        )
 
     controlLine = u"%d %d %d %d %d %d" % (changed_bytes, elapsed, progress, eta, speed, stalled)
-    Log(s, NOTICE, InfoCode.upload_progress, controlLine)
+    Log(s, NOTICE, InfoCode.upload_progress, controlLine, transfer_progress=True)
 
 
 def PrintCollectionStatus(col_stats, force_print=False):
@@ -373,16 +374,45 @@
     outHandler = logging.StreamHandler(sys.stdout)
     if _log_timestamp:
         outHandler.setFormatter(DetailFormatter())
+    else:
+        outHandler.setFormatter(PrettyProgressFormatter())
     outHandler.addFilter(OutFilter())
     _logger.addHandler(outHandler)
 
     errHandler = logging.StreamHandler(sys.stderr)
     if _log_timestamp:
         errHandler.setFormatter(DetailFormatter())
+    else:
+        errHandler.setFormatter(PrettyProgressFormatter())
     errHandler.addFilter(ErrFilter())
     _logger.addHandler(errHandler)
 
 
+class PrettyProgressFormatter(logging.Formatter):
+    u"""Formatter that overwrites previous progress lines on ANSI terminals"""
+    last_record_was_progress = False
+
+    def __init__(self):
+        # 'message' will be appended by format()
+        # Note that we use our own, custom-created 'levelName' instead of the
+        # standard 'levelname'.  This is because the standard 'levelname' can
+        # be adjusted by any library anywhere in our stack without us knowing.
+        # But we control 'levelName'.
+        logging.Formatter.__init__(self, u"%(message)s")
+
+    def format(self, record):
+        s = logging.Formatter.format(self, record)
+
+        # So we don't overwrite actual log lines
+        if self.last_record_was_progress and record.transferProgress:
+            # Go up one line, then erase it
+            s = u"\033[F\033[2K" + s
+
+        self.last_record_was_progress = record.transferProgress
+
+        return s
+
+
 class DetailFormatter(logging.Formatter):
     u"""Formatter that creates messages in a syntax somewhat like syslog."""
     def __init__(self):
diff -Nru duplicity-0.8.18/duplicity/selection.py duplicity-0.8.19/duplicity/selection.py
--- duplicity-0.8.18/duplicity/selection.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/duplicity/selection.py	2021-04-29 18:20:20.000000000 +0000
@@ -361,7 +361,10 @@
         # Internal. Used by ParseArgs.
         log.Notice(_(u"Reading globbing filelist %s") % list_name)
         separator = config.null_separator and u"\0" or u"\n"
-        filelist_fp.seek(0)
+        try:
+            filelist_fp.seek(0)
+        except:
+            pass
         for line in filelist_fp.read().split(separator):
             line, include = self.filelist_sanitise_line(line, inc_default)
             if not line:
diff -Nru duplicity-0.8.18/duplicity/util.py duplicity-0.8.19/duplicity/util.py
--- duplicity-0.8.18/duplicity/util.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/duplicity/util.py	2021-04-29 18:20:20.000000000 +0000
@@ -32,6 +32,7 @@
 from builtins import str
 
 import errno
+import json
 import os
 import string
 import sys
@@ -115,7 +116,7 @@
     # non-ascii will cause a UnicodeDecodeError when implicitly decoding to
     # unicode.  So we decode manually, using the filesystem encoding.
     # 99.99% of the time, this will be a fine encoding to use.
-    if e.args:
+    if e and e.args:
         # Find arg that is a string
         for m in e.args:
             if isinstance(m, str):
@@ -124,6 +125,14 @@
             elif isinstance(m, bytes):
                 # Encoded, likely in filesystem encoding
                 return fsdecode(m)
+        # If the function did not return yet, we did not
+        # succeed in finding a string; return the whole message.
+        # This fails for Python 2, so only do this in Python 3.
+        if sys.version_info[0] > 2:
+            return str(e)
+        # For Python 2, fall back to returning an empty string.
+        else:
+            return u''
     else:
         return u''
 
@@ -265,3 +274,38 @@
                 return exe_file
 
     return None
+
+
+def start_debugger(remote=False):
+    if (not os.getenv(u'DEBUG_RUNNING', None) and (u'--pydevd' in sys.argv or os.getenv(u'PYDEVD', None))):
+        if remote:
+            # modify this for your configuration.
+            # client = base path in machine that Liclipse is on
+            # server = base path in machine that duplicity is on
+            client = u'/Users/ken/workspace/duplicity-testfiles'
+            server = u'/home/ken/workspace/duplicity-testfiles'
+
+            # relative paths under duplicity root
+            duppaths = [
+                u'',
+                u'bin',
+                u'duplicity',
+                u'duplicity/backends',
+                u'testing',
+                u'testing/functional',
+                u'testing/unit',
+            ]
+            pathlist = [(os.path.normpath(os.path.join(client, p)),
+                         os.path.normpath(os.path.join(server, p))) for p in duppaths]
+            os.environ[u'PATHS_FROM_ECLIPSE_TO_PYTHON'] = json.dumps(pathlist)
+
+        import pydevd  # pylint: disable=import-error
+        pydevd.settrace(u'dione.local', port=5678, stdoutToServer=True, stderrToServer=True)
+
+        # In a dev environment the path is screwed so fix it.
+        base = sys.path.pop(0)
+        base = base.split(os.path.sep)[:-1]
+        base = os.path.sep.join(base)
+        sys.path.insert(0, base)
+
+        os.environ[u'DEBUG_RUNNING'] = u'yes'
diff -Nru duplicity-0.8.18/.gitchangelog.rc duplicity-0.8.19/.gitchangelog.rc
--- duplicity-0.8.18/.gitchangelog.rc	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/.gitchangelog.rc	2021-04-29 18:20:20.000000000 +0000
@@ -66,6 +66,7 @@
     r'^([cC]hg|[fF]ix|[nN]ew)\s*:\s*[d|D]ev:',
     r'^(.{3,3}\s*:)?\s*[fF]irst commit.?\s*$',
     r'^Launchpad automatic translations update..*$',
+    r'^.*Change version for LP.*$',
     r'^Update changelog..*$',
     r'^(\* )?Prep\s*for\s*\d+\.\d+\.\d+.*$',
     r'^$',  ## ignore commits with empty messages
@@ -133,12 +134,10 @@
 # body_process = Wrap(regexp=r'\n(?=\w+\s*:)') | Indent(chars="  ")
 # body_process = Wrap(regexp=r'\n(?=\w+\s*:)')
 # body_process = noop
-# body_process = (strip |
-#     ReSub(r'^\* ([A-Za-z])', r'\1') |
-#     ReSub(r'((^|\n)[A-Z]\w+(-\w+)*: .*(\n\s+.*)*)+$', r''))
 body_process = (strip |
-    ReSub('.*\n', '') |
-    ReSub('.*', ''))
+    ReSub(r'^\* ([A-Za-z])', r'\1') |
+    ReSub(r'((^|\n)[A-Z]\w+(-\w+)*: .*(\n\s+.*)*)+$', r'') |
+    Indent(chars="  "))
 
 
 ## ``subject_process`` is a callable
diff -Nru duplicity-0.8.18/.gitlab-ci.yml duplicity-0.8.19/.gitlab-ci.yml
--- duplicity-0.8.18/.gitlab-ci.yml	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/.gitlab-ci.yml	2021-04-29 18:20:20.000000000 +0000
@@ -36,12 +36,9 @@
         # Set locale to prevent UTF-8 errors
         - export LANG=C.UTF-8
         - export LC_ALL=C.UTF-8
-        # Installing some pre-requisites and some
-        # packages needed for testing duplicity
         - apt-get update
         - apt-get install -y 2to3 build-essential git intltool lftp librsync-dev
-          libffi-dev libssl-dev openssl par2 python-dev python-pip python3-dev
-          python3-pip rdiff tzdata
+          libffi-dev libssl-dev openssl par2 rdiff tzdata python3-pip
         - python3 -m pip install --upgrade pip
         - python3 -m pip install --requirement requirements.txt
 
@@ -58,10 +55,12 @@
 py27_ub18-04:
     stage: test
     script:
+        - apt-get install -y python2.7 python2.7-dev
         - tox -e py27
     artifacts:
         reports:
             junit: report.xml
+    allow_failure: true
     needs: ["code_ub18-04"]
 
 py35_ub16-04:
@@ -75,9 +74,10 @@
         - apt-get install -y build-essential git intltool lftp librsync-dev
           libffi-dev libssl-dev openssl par2 rdiff tzdata
           python3-pip python3.5 python3.5-dev
-        - python3 -m pip install --upgrade pip
+        - python3 -m pip install --upgrade pip==20.3.4
         - python3 -m pip install --requirement requirements.txt
     script:
+        - apt-get install -y python3.5 python3.5-dev
         - tox -e py35
     artifacts:
         reports:
@@ -123,11 +123,11 @@
         - export LC_ALL=C.UTF-8
         - apt-get update
         - apt-get install -y build-essential git intltool lftp librsync-dev
-          libffi-dev libssl-dev openssl par2 rdiff tzdata
-          python3-pip python3.9 python3.9-dev
+          libffi-dev libssl-dev openssl par2 rdiff tzdata python3-pip
         - python3 -m pip install --upgrade pip
         - python3 -m pip install --requirement requirements.txt
     script:
+        - apt-get install -y python3.9 python3.9-dev
         - tox -e py39
     artifacts:
         reports:
diff -Nru duplicity-0.8.18/Makefile duplicity-0.8.19/Makefile
--- duplicity-0.8.18/Makefile	1970-01-01 00:00:00.000000000 +0000
+++ duplicity-0.8.19/Makefile	2021-04-29 18:20:20.000000000 +0000
@@ -0,0 +1,13 @@
+.PHONY: clean docs
+
+clean:
+	for i in '.tox' 'build' 'work' 'megatestresults' '.eggs' '*.egg-info' '__pycache__'; do \
+		find . -type d -name "$$i" | xargs -t -r rm -rf ; \
+	done
+
+	for i in '*.pyc' '*.pyo' '*~' '*.o' '*.so' '*.dll' '*.pyd' '*.gcov' '*.gcda' '*.gcno' '*.orig' '*.tmp' 'testdb*' 'testextension.sqlext' ; do \
+		find . -type f -name "$$i" | xargs -t -r rm -f ; \
+	done
+
+docs:
+	sphinx-apidoc -o docs/ -e -f .
diff -Nru duplicity-0.8.18/pylintrc duplicity-0.8.19/pylintrc
--- duplicity-0.8.18/pylintrc	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/pylintrc	2021-04-29 18:20:20.000000000 +0000
@@ -4,13 +4,24 @@
 ignore=_librsync.so
 msg-template='{path}:{line}: [{msg_id}({symbol}), {obj}] {msg}'
 
-disable=access-member-before-definition,
-        undefined-variable,
-        no-name-in-module,
+disable=
+        C,
+        R,
+        access-member-before-definition,
+        invalid-name,
+        line-too-long,
+        missing-function-docstring,
+        missing-module-docstring,
         no-member,
-        not-callable
+        no-name-in-module,
+        not-callable,
+        raise-missing-from,
+        undefined-variable,
+        wrong-import-order,
+        wrong-import-position
 
-enable=unused-argument,
+enable=
+       unused-argument,
        unused-wildcard-import,
        redefined-builtin,
        bad-indentation,
diff -Nru duplicity-0.8.18/README.md duplicity-0.8.19/README.md
--- duplicity-0.8.18/README.md	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/README.md	2021-04-29 18:20:20.000000000 +0000
@@ -33,7 +33,7 @@
  * Boto 2.0 or later for single-processing S3 or GCS access (default)
  * Boto 2.1.1 or later for multi-processing S3 access
  * Boto 2.7.0 or later for Glacier S3 access
- * Boto3 0.3.1 or later
+ * Boto3 1.15 or later for S3
 
 If you install from the source package, you will also need:
 
@@ -54,4 +54,4 @@
 
 or post to the mailing list at
 
-  http://mail.nongnu.org/mailman/listinfo/duplicity-talk/
+  https://lists.nongnu.org/mailman/listinfo/duplicity-talk
diff -Nru duplicity-0.8.18/README-REPO.md duplicity-0.8.19/README-REPO.md
--- duplicity-0.8.18/README-REPO.md	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/README-REPO.md	2021-04-29 18:20:20.000000000 +0000
@@ -7,10 +7,9 @@
    - `git clone git@gitlab.com:duplicity/duplicity.git $DUP_ROOT` or
    - `git clone https://gitlab.com/duplicity/duplicity.git $DUP_ROOT`
 2. Build the extension module
-   - `cd $DUP_ROOT/duplicity`
+   - `cd $DUP_ROOT`
    - `setup.py build_ext`
-   - `cd ..`
-5. Run `PYTHONPATH=$DUP_ROOT bin/duplicity -V`. You will see
+3. Run `PYTHONPATH=$DUP_ROOT bin/duplicity -V`. You will see
    "duplicity $version" instead of the normal version number.
    Versioning comes during the release.
 
diff -Nru duplicity-0.8.18/requirements.txt duplicity-0.8.19/requirements.txt
--- duplicity-0.8.18/requirements.txt	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/requirements.txt	2021-04-29 18:20:20.000000000 +0000
@@ -2,41 +2,48 @@
 
 fasteners
 future
-mock
+mock==3.0.5
 python-gettext
 requests
-setuptools  #>=45.2.0
-setuptools_scm  # >=3.4.3
+setuptools>=44.1.1
+setuptools_scm>=5.0.2
 urllib3
 
 
 ##### testing libraries #####
 
+# some libs no longer support py27
+
 coverage
 paramiko
 pexpect
 psutil
 pycodestyle
-pydevd
+pydevd                  ; python_version >= '3.6'
 pylint
 pytest
 pytest-cov
-pytest-runner
+pytest-runner           ; python_version >= '3.6'
 sphinx
 tox
 
 
 ##### backend libraries #####
 
-# azure-mgmt-storage
-# b2sdk
-# boto
-# boto3
-# dropbox
-# gdata
-# jottalib
-# mediafire
-# pydrive
-# pyrax
-# python-swiftclient
-# requests_oauthlib
+# some libs no longer support py27
+# some libs never supported py36+
+
+azure-storage-blob      ; python_version >= '3.6'
+b2sdk                   ; python_version >= '3.6'
+boto
+boto3
+boxsdk[jwt]             ; python_version >= '3.6'
+dropbox
+gdata                   ; python_version == '2.7'
+google_auth_oauthlib
+jottalib
+mediafire
+pydrive                 ; python_version >= '3.6'
+pyrax                   ; python_version >= '3.6'
+python-swiftclient
+requests_oauthlib
diff -Nru duplicity-0.8.18/setup.py duplicity-0.8.19/setup.py
--- duplicity-0.8.18/setup.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/setup.py	2021-04-29 18:20:20.000000000 +0000
@@ -52,7 +52,7 @@
     from setuptools_scm import get_version  # pylint: disable=import-error
     Version = get_version(**scm_version_args)
 except Exception as e:
-    Version = u"0.8.18"
+    Version = u"0.8.19"
     print(u"Unable to get SCM version: defaulting to %s" % (Version,))
 Reldate = time.strftime(u"%B %d, %Y", time.localtime())
 
@@ -244,47 +244,6 @@
                     VersionedCopy(path, path)
 
 
-class BuildScriptsCommand(build_scripts):
-    u'''Build but don't touch my shebang!'''
-
-    def run(self):
-        u"""
-        Copy, chmod each script listed in 'self.scripts'
-        essentially this is the stripped
-         distutils.command.build_scripts.copy_scripts()
-        routine
-        """
-        from stat import ST_MODE
-        from distutils.dep_util import newer
-        from distutils import log
-
-        self.mkpath(self.build_dir)
-        outfiles = []
-        for script in self.scripts:
-            outfile = os.path.join(self.build_dir, os.path.basename(script))
-            outfiles.append(outfile)
-
-            if not self.force and not newer(script, outfile):
-                log.debug(u"not copying %s (up-to-date)", script)
-                continue
-
-            log.info(u"copying and NOT adjusting %s -> %s", script,
-                     self.build_dir)
-            self.copy_file(script, outfile)
-
-        if os.name == u'posix':
-            for file in outfiles:
-                if self.dry_run:
-                    log.info(u"changing mode of %s", file)
-                else:
-                    oldmode = os.stat(file)[ST_MODE] & 0o7777
-                    newmode = (oldmode | 0o555) & 0o7777
-                    if newmode != oldmode:
-                        log.info(u"changing mode of %s from %o to %o",
-                                 file, oldmode, newmode)
-                        os.chmod(file, newmode)
-
-
 with open(u"README.md") as fh:
     long_description = fh.read()
 
@@ -339,7 +298,6 @@
         ],
     test_suite=u"testing",
     cmdclass={
-        u"build_scripts": BuildScriptsCommand,
         u"install": InstallCommand,
         u"install_data": InstallDataCommand,
         u"sdist": SdistCommand,
diff -Nru duplicity-0.8.18/testing/functional/__init__.py duplicity-0.8.19/testing/functional/__init__.py
--- duplicity-0.8.18/testing/functional/__init__.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/testing/functional/__init__.py	2021-04-29 18:20:20.000000000 +0000
@@ -32,6 +32,8 @@
 from duplicity import backend
 from duplicity import util
 from .. import DuplicityTestCase
+from .. import _top_dir
+from .. import _runtest_dir
 from pkg_resources import parse_version
 
 
@@ -68,7 +70,7 @@
         self.unpack_testfiles()
 
         self.class_args = []
-        self.backend_url = u"file://testfiles/output"
+        self.backend_url = u"file://{0}/testfiles/output".format(_runtest_dir)
         self.last_backup = None
         self.set_environ(u'PASSPHRASE', self.sign_passphrase)
         self.set_environ(u"SIGN_PASSPHRASE", self.sign_passphrase)
@@ -109,12 +111,12 @@
         run_coverage = os.environ.get(u'RUN_COVERAGE', None)
         if run_coverage is not None:
             cmd_list.extend([u"-m", u"coverage", u"run", u"--source=duplicity", u"-p"])
-        cmd_list.extend([u"../bin/duplicity"])
+        cmd_list.extend([u"{0}/bin/duplicity".format(_top_dir)])
         cmd_list.extend(options)
         cmd_list.extend([u"-v0"])
         cmd_list.extend([u"--no-print-statistics"])
         cmd_list.extend([u"--allow-source-mismatch"])
-        cmd_list.extend([u"--archive-dir=testfiles/cache"])
+        cmd_list.extend([u"--archive-dir={0}/testfiles/cache".format(_runtest_dir)])
         if current_time:
             cmd_list.extend([u"--current-time", current_time])
         cmd_list.extend(self.class_args)
@@ -191,8 +193,8 @@
         return after_files - before_files
 
     def restore(self, file_to_restore=None, time=None, options=[], **kwargs):
-        assert not os.system(u"rm -rf testfiles/restore_out")
-        options = [self.backend_url, u"testfiles/restore_out"] + options
+        assert not os.system(u"rm -rf {0}/testfiles/restore_out".format(_runtest_dir))
+        options = [self.backend_url, u"{0}/testfiles/restore_out".format(_runtest_dir)] + options
         if file_to_restore:
             options.extend([u'--file-to-restore', file_to_restore])
         if time:
@@ -223,9 +225,11 @@
 
     def make_largefiles(self, count=3, size=2):
         u"""
-        Makes a number of large files in testfiles/largefiles that each are
+        Makes a number of large files in /tmp/testfiles/largefiles that each are
         the specified number of megabytes.
         """
-        assert not os.system(u"mkdir testfiles/largefiles")
+        assert not os.system(u"mkdir {0}/testfiles/largefiles".format(_runtest_dir))
         for n in range(count):
-            assert not os.system(u"dd if=/dev/urandom of=testfiles/largefiles/file%d bs=1024 count=%d > /dev/null 2>&1" % (n + 1, size * 1024))
+            assert not os.system(
+                u"dd if=/dev/urandom of={0}/testfiles/largefiles/file{1} bs=1024 count={2} > /dev/null 2>&1".format(
+                    _runtest_dir, n + 1, size * 1024))
diff -Nru duplicity-0.8.18/testing/functional/test_badupload.py duplicity-0.8.19/testing/functional/test_badupload.py
--- duplicity-0.8.18/testing/functional/test_badupload.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/testing/functional/test_badupload.py	2021-04-29 18:20:20.000000000 +0000
@@ -26,6 +26,7 @@
 
 import unittest
 
+from testing import _runtest_dir
 from . import CmdError, FunctionalTestCase
 
 
@@ -38,7 +39,7 @@
         Test basic lost file
         """
         try:
-            self.backup(u"full", u"testfiles/dir1", options=[u"--skip-volume=1"])
+            self.backup(u"full", u"{0}/testfiles/dir1".format(_runtest_dir), options=[u"--skip-volume=1"])
             self.fail()
         except CmdError as e:
             self.assertEqual(e.exit_status, 44, str(e))
diff -Nru duplicity-0.8.18/testing/functional/test_cleanup.py duplicity-0.8.19/testing/functional/test_cleanup.py
--- duplicity-0.8.18/testing/functional/test_cleanup.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/testing/functional/test_cleanup.py	2021-04-29 18:20:20.000000000 +0000
@@ -25,6 +25,7 @@
 
 import unittest
 
+from testing import _runtest_dir
 from . import FunctionalTestCase
 
 
@@ -39,10 +40,10 @@
         after a failed backup.
         """
         self.make_largefiles()
-        good_files = self.backup(u"full", u"testfiles/largefiles")
-        good_files |= self.backup(u"inc", u"testfiles/largefiles")
-        good_files |= self.backup(u"inc", u"testfiles/largefiles")
-        self.backup(u"full", u"testfiles/largefiles", fail=1)
+        good_files = self.backup(u"full", u"{0}/testfiles/largefiles".format(_runtest_dir))
+        good_files |= self.backup(u"inc", u"{0}/testfiles/largefiles".format(_runtest_dir))
+        good_files |= self.backup(u"inc", u"{0}/testfiles/largefiles".format(_runtest_dir))
+        self.backup(u"full", u"{0}/testfiles/largefiles".format(_runtest_dir), fail=1)
         bad_files = self.get_backend_files()
         bad_files -= good_files
         self.assertNotEqual(bad_files, set())
@@ -50,15 +51,15 @@
         self.run_duplicity(options=[u"cleanup", self.backend_url, u"--force"])
         leftovers = self.get_backend_files()
         self.assertEqual(good_files, leftovers)
-        self.backup(u"inc", u"testfiles/largefiles")
-        self.verify(u"testfiles/largefiles")
+        self.backup(u"inc", u"{0}/testfiles/largefiles".format(_runtest_dir))
+        self.verify(u"{0}/testfiles/largefiles".format(_runtest_dir))
 
     def test_remove_all_but_n(self):
         u"""
         Test that remove-all-but-n works in the simple case.
         """
-        full1_files = self.backup(u"full", u"testfiles/empty_dir")
-        full2_files = self.backup(u"full", u"testfiles/empty_dir")
+        full1_files = self.backup(u"full", u"{0}/testfiles/empty_dir".format(_runtest_dir))
+        full2_files = self.backup(u"full", u"{0}/testfiles/empty_dir".format(_runtest_dir))
         self.run_duplicity(options=[u"remove-all-but-n", u"1", self.backend_url, u"--force"])
         leftovers = self.get_backend_files()
         self.assertEqual(full2_files, leftovers)
@@ -67,9 +68,9 @@
         u"""
         Test that remove-all-inc-of-but-n-full works in the simple case.
         """
-        full1_files = self.backup(u"full", u"testfiles/empty_dir")
-        inc1_files = self.backup(u"inc", u"testfiles/empty_dir")
-        full2_files = self.backup(u"full", u"testfiles/empty_dir")
+        full1_files = self.backup(u"full", u"{0}/testfiles/empty_dir".format(_runtest_dir))
+        inc1_files = self.backup(u"inc", u"{0}/testfiles/empty_dir".format(_runtest_dir))
+        full2_files = self.backup(u"full", u"{0}/testfiles/empty_dir".format(_runtest_dir))
         self.run_duplicity(options=[u"remove-all-inc-of-but-n-full", u"1", self.backend_url, u"--force"])
         leftovers = self.get_backend_files()
         self.assertEqual(full1_files | full2_files, leftovers)
diff -Nru duplicity-0.8.18/testing/functional/test_final.py duplicity-0.8.19/testing/functional/test_final.py
--- duplicity-0.8.18/testing/functional/test_final.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/testing/functional/test_final.py	2021-04-29 18:20:20.000000000 +0000
@@ -28,6 +28,7 @@
 import unittest
 
 from duplicity import path
+from testing import _runtest_dir
 from . import CmdError, FunctionalTestCase
 
 
@@ -53,7 +54,7 @@
             dirname = dirlist[i]
             current_time = 100000 * (i + 1)
             self.restore(time=current_time, options=restore_options)
-            self.check_same(dirname, u"testfiles/restore_out")
+            self.check_same(dirname, u"{0}/testfiles/restore_out".format(_runtest_dir))
             self.verify(dirname,
                         time=current_time, options=restore_options)
 
@@ -64,9 +65,9 @@
 
     def test_basic_cycle(self, backup_options=[], restore_options=[]):
         u"""Run backup/restore test on basic directories"""
-        self.runtest([u"testfiles/dir1",
-                      u"testfiles/dir2",
-                      u"testfiles/dir3"],
+        self.runtest([u"{0}/testfiles/dir1".format(_runtest_dir),
+                      u"{0}/testfiles/dir2".format(_runtest_dir),
+                      u"{0}/testfiles/dir3".format(_runtest_dir)],
                      backup_options=backup_options,
                      restore_options=restore_options)
 
@@ -76,9 +77,9 @@
                                     (u'directory_to_file', 200100, u'dir2'),
                                     (u'largefile', 300000, u'dir3')]:
             self.restore(filename, time, options=restore_options)
-            self.check_same(u'testfiles/%s/%s' % (dir, filename),
-                            u'testfiles/restore_out')
-            self.verify(u'testfiles/%s/%s' % (dir, filename),
+            self.check_same(u'{0}/testfiles/{1}/{2}'.format(_runtest_dir, dir, filename),
+                            u'{0}/testfiles/restore_out'.format(_runtest_dir))
+            self.verify(u'{0}/testfiles/{1}/{2}'.format(_runtest_dir, dir, filename),
                         file_to_verify=filename, time=time,
                         options=restore_options)
 
@@ -102,19 +103,19 @@
 
     def test_single_regfile(self):
         u"""Test backing and restoring up a single regular file"""
-        self.runtest([u"testfiles/various_file_types/regular_file"])
+        self.runtest([u"{0}/testfiles/various_file_types/regular_file".format(_runtest_dir)])
 
     def test_empty_backup(self):
         u"""Make sure backup works when no files change"""
-        self.backup(u"full", u"testfiles/empty_dir")
-        self.backup(u"inc", u"testfiles/empty_dir")
+        self.backup(u"full", u"{0}/testfiles/empty_dir".format(_runtest_dir))
+        self.backup(u"inc", u"{0}/testfiles/empty_dir".format(_runtest_dir))
 
     def test_long_filenames(self):
         u"""Test backing up a directory with long filenames in it"""
         # Note that some versions of ecryptfs (at least through Ubuntu 11.10)
         # have a bug where they treat the max path segment length as 143
         # instead of 255.  So make sure that these segments don't break that.
-        lf_dir = path.Path(u"testfiles/long_filenames")
+        lf_dir = path.Path(u"{0}/testfiles/long_filenames".format(_runtest_dir))
         if lf_dir.exists():
             lf_dir.deltree()
         lf_dir.mkdir()
@@ -135,22 +136,22 @@
         fp.write(b"hello" * 1000)
         assert not fp.close()
 
-        self.runtest([u"testfiles/empty_dir", lf_dir.uc_name,
-                      u"testfiles/empty_dir", lf_dir.uc_name])
+        self.runtest([u"{0}/testfiles/empty_dir".format(_runtest_dir), lf_dir.uc_name,
+                      u"{0}/testfiles/empty_dir".format(_runtest_dir), lf_dir.uc_name])
 
     def test_empty_restore(self):
         u"""Make sure error raised when restore doesn't match anything"""
-        self.backup(u"full", u"testfiles/dir1")
+        self.backup(u"full", u"{0}/testfiles/dir1".format(_runtest_dir))
         self.assertRaises(CmdError, self.restore, u"this_file_does_not_exist")
-        self.backup(u"inc", u"testfiles/empty_dir")
+        self.backup(u"inc", u"{0}/testfiles/empty_dir".format(_runtest_dir))
         self.assertRaises(CmdError, self.restore, u"this_file_does_not_exist")
 
     def test_remove_older_than(self):
         u"""Test removing old backup chains"""
-        first_chain = self.backup(u"full", u"testfiles/dir1", current_time=10000)
-        first_chain |= self.backup(u"inc", u"testfiles/dir2", current_time=20000)
-        second_chain = self.backup(u"full", u"testfiles/dir1", current_time=30000)
-        second_chain |= self.backup(u"inc", u"testfiles/dir3", current_time=40000)
+        first_chain = self.backup(u"full", u"{0}/testfiles/dir1".format(_runtest_dir), current_time=10000)
+        first_chain |= self.backup(u"inc", u"{0}/testfiles/dir2".format(_runtest_dir), current_time=20000)
+        second_chain = self.backup(u"full", u"{0}/testfiles/dir1".format(_runtest_dir), current_time=30000)
+        second_chain |= self.backup(u"inc", u"{0}/testfiles/dir3".format(_runtest_dir), current_time=40000)
 
         self.assertEqual(self.get_backend_files(), first_chain | second_chain)
 
@@ -164,7 +165,7 @@
     def test_piped_password(self):
         u"""Make sure that prompting for a password works"""
         self.set_environ(u"PASSPHRASE", None)
-        self.backup(u"full", u"testfiles/empty_dir",
+        self.backup(u"full", u"{0}/testfiles/empty_dir".format(_runtest_dir),
                     passphrase_input=[self.sign_passphrase, self.sign_passphrase])
         self.restore(passphrase_input=[self.sign_passphrase])
 
diff -Nru duplicity-0.8.18/testing/functional/test_log.py duplicity-0.8.19/testing/functional/test_log.py
--- duplicity-0.8.18/testing/functional/test_log.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/testing/functional/test_log.py	2021-04-29 18:20:20.000000000 +0000
@@ -26,20 +26,22 @@
 import os
 
 from . import FunctionalTestCase
+from testing import _top_dir
+from testing import _runtest_dir
 
 
 class LogTest(FunctionalTestCase):
     u"""Test machine-readable functions/classes in log.py"""
 
-    logfile = os.environ.get(u'TMPDIR', u'/tmp') + u'/duplicity.log'
+    logfile = u"{0}/duplicity.log".format(_runtest_dir)
 
     def setUp(self):
         super(LogTest, self).setUp()
-        assert not os.system(u"rm -f {}".format(self.logfile))
+        assert not os.system(u"rm -f {0}".format(self.logfile))
 
     def tearDown(self):
         super(LogTest, self).tearDown()
-        assert not os.system(u"rm -f {}".format(self.logfile))
+        assert not os.system(u"rm -f {0}".format(self.logfile))
 
     def test_command_line_error(self):
         u"""Check notification of a simple error code"""
@@ -47,9 +49,9 @@
         # Run actual duplicity command (will fail, because no arguments passed)
         basepython = os.environ.get(u'TOXPYTHON', None)
         if basepython is not None:
-            os.system(u"{} ../bin/duplicity --log-file={} >/dev/null 2>&1".format(basepython, self.logfile))
+            os.system(u"{0} {1}/bin/duplicity --log-file={2} >/dev/null 2>&1".format(basepython, _top_dir, self.logfile))
         else:
-            os.system(u"../bin/duplicity --log-file={} >/dev/null 2>&1".format(self.logfile))
+            os.system(u"{0}/bin/duplicity --log-file={1} >/dev/null 2>&1".format(_top_dir, self.logfile))
 
         # The format of the file should be:
         # """ERROR 2
diff -Nru duplicity-0.8.18/testing/functional/test_rdiffdir.py duplicity-0.8.19/testing/functional/test_rdiffdir.py
--- duplicity-0.8.18/testing/functional/test_rdiffdir.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/testing/functional/test_rdiffdir.py	2021-04-29 18:20:20.000000000 +0000
@@ -27,6 +27,8 @@
 import os
 
 from duplicity import path
+from testing import _top_dir
+from testing import _runtest_dir
 from . import FunctionalTestCase
 
 
@@ -42,7 +44,7 @@
         basepython = os.environ.get(u'TOXPYTHON', None)
         if basepython is not None:
             cmd_list.extend([basepython])
-        cmd_list.extend([u"../bin/rdiffdir"])
+        cmd_list.extend([u"{0}/bin/rdiffdir".format(_top_dir)])
         cmd_list.extend(argstring.split())
         cmdline = u" ".join([u'"%s"' % x for x in cmd_list])
         self.run_cmd(cmdline)
@@ -51,10 +53,10 @@
         u"""Run diff/patch cycle on directories in dirname_list"""
         assert len(dirname_list) >= 2
 
-        seq_path = path.Path(u"testfiles/output/sequence")
+        seq_path = path.Path(u"{0}/testfiles/output/sequence".format(_runtest_dir))
         new_path = path.Path(dirname_list[0])
-        delta_path = path.Path(u"testfiles/output/delta.tar")
-        sig_path = path.Path(u"testfiles/output/sig.tar")
+        delta_path = path.Path(u"{0}/testfiles/output/delta.tar".format(_runtest_dir))
+        sig_path = path.Path(u"{0}/testfiles/output/sig.tar".format(_runtest_dir))
 
         self.run_cmd(u"cp -pR %s %s" % (new_path.uc_name, seq_path.uc_name))
         seq_path.setdata()
@@ -90,12 +92,12 @@
             assert sig_path.isreg()
 
     def test_dirx(self):
-        u"""Test cycle on testfiles/dirx"""
-        self.run_cycle([u'testfiles/empty_dir',
-                        u'testfiles/dir1',
-                        u'testfiles/dir2',
-                        u'testfiles/dir3',
-                        u'testfiles/empty_dir'])
+        u"""Test cycle on {0}/testfiles/dirx"""
+        self.run_cycle([u'{0}/testfiles/empty_dir'.format(_runtest_dir),
+                        u'{0}/testfiles/dir1'.format(_runtest_dir),
+                        u'{0}/testfiles/dir2'.format(_runtest_dir),
+                        u'{0}/testfiles/dir3'.format(_runtest_dir),
+                        u'{0}/testfiles/empty_dir'.format(_runtest_dir)])
 
 
 if __name__ == u"__main__":
diff -Nru duplicity-0.8.18/testing/functional/test_replicate.py duplicity-0.8.19/testing/functional/test_replicate.py
--- duplicity-0.8.18/testing/functional/test_replicate.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/testing/functional/test_replicate.py	2021-04-29 18:20:20.000000000 +0000
@@ -25,6 +25,7 @@
 standard_library.install_aliases()
 
 from duplicity import path
+from testing import _runtest_dir
 from . import FunctionalTestCase
 
 
@@ -45,7 +46,7 @@
 
         # Replicate to other backend
         source_url = self.backend_url
-        target_url = u"file://testfiles/replicate_out"
+        target_url = u"file://{0}/testfiles/replicate_out".format(_runtest_dir)
         self.run_duplicity(options=[u"replicate"] +
                            replicate_options + [source_url, target_url])
 
@@ -56,7 +57,7 @@
             dirname = dirlist[i]
             current_time = 100000 * (i + 1)
             self.restore(time=current_time, options=restore_options)
-            self.check_same(dirname, u"testfiles/restore_out")
+            self.check_same(dirname, u"{0}/testfiles/restore_out".format(_runtest_dir))
             self.verify(dirname,
                         time=current_time, options=restore_options)
 
@@ -67,15 +68,15 @@
 
     def test_replicate(self):
         u"""Test replication"""
-        self.runtest([u"testfiles/dir1", u"testfiles/dir2"])
+        self.runtest([u"{0}/testfiles/dir1".format(_runtest_dir), u"{0}/testfiles/dir2".format(_runtest_dir)])
 
     def test_replicate_noencryption(self):
         u"""Test replication with decryption"""
-        self.runtest([u"testfiles/dir1", u"testfiles/dir2"],
+        self.runtest([u"{0}/testfiles/dir1".format(_runtest_dir), u"{0}/testfiles/dir2".format(_runtest_dir)],
                      replicate_options=[u"--no-encryption"])
 
     def test_replicate_asym(self):
         u"""Test replication with reencryption"""
         asym_options = [u"--encrypt-key", self.encrypt_key1]
-        self.runtest([u"testfiles/dir1", u"testfiles/dir2"],
+        self.runtest([u"{0}/testfiles/dir1".format(_runtest_dir), u"{0}/testfiles/dir2".format(_runtest_dir)],
                      replicate_options=asym_options, restore_options=asym_options)
diff -Nru duplicity-0.8.18/testing/functional/test_restart.py duplicity-0.8.19/testing/functional/test_restart.py
--- duplicity-0.8.18/testing/functional/test_restart.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/testing/functional/test_restart.py	2021-04-29 18:20:20.000000000 +0000
@@ -30,6 +30,7 @@
 import sys
 import unittest
 
+from testing import _runtest_dir
 from . import FunctionalTestCase
 
 
@@ -43,9 +44,9 @@
         Test basic Checkpoint/Restart
         """
         self.make_largefiles()
-        self.backup(u"full", u"testfiles/largefiles", fail=1)
-        self.backup(u"full", u"testfiles/largefiles")
-        self.verify(u"testfiles/largefiles")
+        self.backup(u"full", u"{0}/testfiles/largefiles".format(_runtest_dir), fail=1)
+        self.backup(u"full", u"{0}/testfiles/largefiles".format(_runtest_dir))
+        self.verify(u"{0}/testfiles/largefiles".format(_runtest_dir))
 
     @unittest.skipIf(sys.version_info.major == 2, u"Skip on possible timing error")
     def test_multiple_checkpoint_restart(self):
@@ -53,11 +54,11 @@
         Test multiple Checkpoint/Restart
         """
         self.make_largefiles()
-        self.backup(u"full", u"testfiles/largefiles", fail=1)
-        self.backup(u"full", u"testfiles/largefiles", fail=2)
-        self.backup(u"full", u"testfiles/largefiles", fail=3)
-        self.backup(u"full", u"testfiles/largefiles")
-        self.verify(u"testfiles/largefiles")
+        self.backup(u"full", u"{0}/testfiles/largefiles".format(_runtest_dir), fail=1)
+        self.backup(u"full", u"{0}/testfiles/largefiles".format(_runtest_dir), fail=2)
+        self.backup(u"full", u"{0}/testfiles/largefiles".format(_runtest_dir), fail=3)
+        self.backup(u"full", u"{0}/testfiles/largefiles".format(_runtest_dir))
+        self.verify(u"{0}/testfiles/largefiles".format(_runtest_dir))
 
     @unittest.skipIf(sys.version_info.major == 2, u"Skip on possible timing error")
     def test_first_volume_failure(self):
@@ -66,10 +67,10 @@
         Caused when duplicity fails before the first transfer.
         """
         self.make_largefiles()
-        self.backup(u"full", u"testfiles/largefiles", fail=1)
-        assert not os.system(u"rm testfiles/output/duplicity-full*difftar*")
-        self.backup(u"full", u"testfiles/largefiles")
-        self.verify(u"testfiles/largefiles")
+        self.backup(u"full", u"{0}/testfiles/largefiles".format(_runtest_dir), fail=1)
+        assert not os.system(u"rm {0}/testfiles/output/duplicity-full*difftar*".format(_runtest_dir))
+        self.backup(u"full", u"{0}/testfiles/largefiles".format(_runtest_dir))
+        self.verify(u"{0}/testfiles/largefiles".format(_runtest_dir))
 
     @unittest.skipIf(sys.version_info.major == 2, u"Skip on possible timing error")
     def test_multi_volume_failure(self):
@@ -79,10 +80,10 @@
         fails the last queued transfer(s).
         """
         self.make_largefiles()
-        self.backup(u"full", u"testfiles/largefiles", fail=3)
-        assert not os.system(u"rm testfiles/output/duplicity-full*vol[23].difftar*")
-        self.backup(u"full", u"testfiles/largefiles")
-        self.verify(u"testfiles/largefiles")
+        self.backup(u"full", u"{0}/testfiles/largefiles".format(_runtest_dir), fail=3)
+        assert not os.system(u"rm {0}/testfiles/output/duplicity-full*vol[23].difftar*".format(_runtest_dir))
+        self.backup(u"full", u"{0}/testfiles/largefiles".format(_runtest_dir))
+        self.verify(u"{0}/testfiles/largefiles".format(_runtest_dir))
 
     @unittest.skipIf(sys.version_info.major == 2, u"Skip on possible timing error")
     def test_restart_encrypt_without_password(self):
@@ -95,11 +96,11 @@
         self.set_environ(u'SIGN_PASSPHRASE', None)
         self.make_largefiles()
         enc_opts = [u"--encrypt-key", self.encrypt_key1]
-        self.backup(u"full", u"testfiles/largefiles", options=enc_opts, fail=2)
-        self.backup(u"full", u"testfiles/largefiles", options=enc_opts)
+        self.backup(u"full", u"{0}/testfiles/largefiles".format(_runtest_dir), options=enc_opts, fail=2)
+        self.backup(u"full", u"{0}/testfiles/largefiles".format(_runtest_dir), options=enc_opts)
 
         self.set_environ(u'PASSPHRASE', self.sign_passphrase)
-        self.verify(u"testfiles/largefiles")
+        self.verify(u"{0}/testfiles/largefiles".format(_runtest_dir))
 
     @unittest.skipIf(sys.version_info.major == 2, u"Skip on possible timing error")
     def test_restart_sign_and_encrypt(self):
@@ -109,9 +110,9 @@
         """
         self.make_largefiles()
         enc_opts = [u"--sign-key", self.sign_key, u"--encrypt-key", self.sign_key]
-        self.backup(u"full", u"testfiles/largefiles", options=enc_opts, fail=2)
-        self.backup(u"full", u"testfiles/largefiles", options=enc_opts)
-        self.verify(u"testfiles/largefiles")
+        self.backup(u"full", u"{0}/testfiles/largefiles".format(_runtest_dir), options=enc_opts, fail=2)
+        self.backup(u"full", u"{0}/testfiles/largefiles".format(_runtest_dir), options=enc_opts)
+        self.verify(u"{0}/testfiles/largefiles".format(_runtest_dir))
 
     @unittest.skipIf(sys.version_info.major == 2, u"Skip on possible timing error")
     def test_restart_sign_and_hidden_encrypt(self):
@@ -121,9 +122,9 @@
         """
         self.make_largefiles()
         enc_opts = [u"--sign-key", self.sign_key, u"--hidden-encrypt-key", self.sign_key]
-        self.backup(u"full", u"testfiles/largefiles", options=enc_opts, fail=2)
-        self.backup(u"full", u"testfiles/largefiles", options=enc_opts)
-        self.verify(u"testfiles/largefiles")
+        self.backup(u"full", u"{0}/testfiles/largefiles".format(_runtest_dir), options=enc_opts, fail=2)
+        self.backup(u"full", u"{0}/testfiles/largefiles".format(_runtest_dir), options=enc_opts)
+        self.verify(u"{0}/testfiles/largefiles".format(_runtest_dir))
 
     def test_last_file_missing_in_middle(self):
         u"""
@@ -132,10 +133,10 @@
         the file in the middle of the backup, with files following.
         """
         self.make_largefiles()
-        self.backup(u"full", u"testfiles/largefiles", fail=3)
-        assert not os.system(u"rm testfiles/largefiles/file2")
-        self.backup(u"full", u"testfiles/largefiles")
-        self.verify(u"testfiles/largefiles")
+        self.backup(u"full", u"{0}/testfiles/largefiles".format(_runtest_dir), fail=3)
+        assert not os.system(u"rm {0}/testfiles/largefiles/file2".format(_runtest_dir))
+        self.backup(u"full", u"{0}/testfiles/largefiles".format(_runtest_dir))
+        self.verify(u"{0}/testfiles/largefiles".format(_runtest_dir))
 
     @unittest.skipIf(u"ppc64el" in platform.machine(), u"Skip on ppc64el machines")
     def test_last_file_missing_at_end(self):
@@ -145,20 +146,20 @@
         the file at the end of the backup, with no files following.
         """
         self.make_largefiles()
-        self.backup(u"full", u"testfiles/largefiles", fail=6)
-        assert not os.system(u"rm testfiles/largefiles/file3")
-        self.backup(u"full", u"testfiles/largefiles")
-        self.verify(u"testfiles/largefiles")
+        self.backup(u"full", u"{0}/testfiles/largefiles".format(_runtest_dir), fail=6)
+        assert not os.system(u"rm {0}/testfiles/largefiles/file3".format(_runtest_dir))
+        self.backup(u"full", u"{0}/testfiles/largefiles".format(_runtest_dir))
+        self.verify(u"{0}/testfiles/largefiles".format(_runtest_dir))
 
     def test_restart_incremental(self):
         u"""
         Test restarting an incremental backup
         """
         self.make_largefiles()
-        self.backup(u"full", u"testfiles/dir1")
-        self.backup(u"inc", u"testfiles/largefiles", fail=2)
-        self.backup(u"inc", u"testfiles/largefiles")
-        self.verify(u"testfiles/largefiles")
+        self.backup(u"full", u"{0}/testfiles/dir1".format(_runtest_dir))
+        self.backup(u"inc", u"{0}/testfiles/largefiles".format(_runtest_dir), fail=2)
+        self.backup(u"inc", u"{0}/testfiles/largefiles".format(_runtest_dir))
+        self.verify(u"{0}/testfiles/largefiles".format(_runtest_dir))
 
     def make_fake_second_volume(self, name):
         u"""
@@ -168,39 +169,39 @@
         found because it may have not finished uploading.)
         """
         # First, confirm that we have signs of a successful backup
-        self.assertEqual(len(glob.glob(u"testfiles/output/*.manifest*")), 1)
-        self.assertEqual(len(glob.glob(u"testfiles/output/*.sigtar*")), 1)
-        self.assertEqual(len(glob.glob(u"testfiles/cache/%s/*" % name)), 3)
+        self.assertEqual(len(glob.glob(u"{0}/testfiles/output/*.manifest*".format(_runtest_dir))), 1)
+        self.assertEqual(len(glob.glob(u"{0}/testfiles/output/*.sigtar*".format(_runtest_dir))), 1)
+        self.assertEqual(len(glob.glob(u"{0}/testfiles/cache/{1}/*".format(_runtest_dir, name))), 3)
         self.assertEqual(len(glob.glob(
-            u"testfiles/cache/%s/*.manifest*" % name)), 1)
+            u"{0}/testfiles/cache/{1}/*.manifest*".format(_runtest_dir, name))), 1)
         self.assertEqual(len(glob.glob(
-            u"testfiles/cache/%s/*.sigtar*" % name)), 1)
+            u"{0}/testfiles/cache/{1}/*.sigtar*".format(_runtest_dir, name))), 1)
         # Alright, everything is in order; fake a second interrupted volume
-        assert not os.system(u"rm testfiles/output/*.manifest*")
-        assert not os.system(u"rm testfiles/output/*.sigtar*")
-        assert not os.system(u"rm -f testfiles/output/*.vol[23456789].*")
-        assert not os.system(u"rm -f testfiles/output/*.vol1[^.]+.*")
-        self.assertEqual(len(glob.glob(u"testfiles/output/*.difftar*")), 1)
-        assert not os.system(u"rm testfiles/cache/%s/*.sigtar*" % name)
-        assert not os.system(u"cp testfiles/output/*.difftar* "
-                             u"`ls testfiles/output/*.difftar* | "
+        assert not os.system(u"rm {0}/testfiles/output/*.manifest*".format(_runtest_dir))
+        assert not os.system(u"rm {0}/testfiles/output/*.sigtar*".format(_runtest_dir))
+        assert not os.system(u"rm -f {0}/testfiles/output/*.vol[23456789].*".format(_runtest_dir))
+        assert not os.system(u"rm -f {0}/testfiles/output/*.vol1[^.]+.*".format(_runtest_dir))
+        self.assertEqual(len(glob.glob(u"{0}/testfiles/output/*.difftar*".format(_runtest_dir))), 1)
+        assert not os.system(u"rm {0}/testfiles/cache/{1}/*.sigtar*".format(_runtest_dir, name))
+        assert not os.system(u"cp {0}/testfiles/output/*.difftar* ".format(_runtest_dir) +
+                             u"`ls {0}/testfiles/output/*.difftar* | ".format(_runtest_dir) +
                              u" sed 's|vol1|vol2|'`")
-        assert not os.system(u"head -n6 testfiles/cache/%s/*.manifest > "
-                             u"testfiles/cache/%s/"
-                             u"`basename testfiles/cache/%s/*.manifest`"
-                             u".part" % (name, name, name))
-        assert not os.system(u"rm testfiles/cache/%s/*.manifest" % name)
+        assert not os.system(u"head -n6 {0}/testfiles/cache/{1}/*.manifest > ".format(_runtest_dir, name) +
+                             u"{0}/testfiles/cache/{1}/".format(_runtest_dir, name) +
+                             u"`basename {0}/testfiles/cache/{1}/*.manifest`".format(_runtest_dir, name) +
+                             u".part")
+        assert not os.system(u"rm {0}/testfiles/cache/{1}/*.manifest".format(_runtest_dir, name))
         assert not os.system(u"""echo 'Volume 2:
     StartingPath   foo
     EndingPath     bar
-    Hash SHA1 sha1' >> testfiles/cache/%s/*.manifest.part""" % name)
+    Hash SHA1 sha1' >> /tmp/testfiles/cache/%s/*.manifest.part""" % name)
 
     def test_split_after_small(self):
         u"""
         If we restart right after a volume that ended with a small
         (one-block) file, make sure we restart in the right place.
         """
-        source = u'testfiles/largefiles'
+        source = u'{0}/testfiles/largefiles'.format(_runtest_dir)
         assert not os.system(u"mkdir -p %s" % source)
         assert not os.system(u"echo hello > %s/file1" % source)
         self.backup(u"full", source, options=[u"--name=backup1"])
@@ -211,17 +212,17 @@
         # 'restart' the backup
         self.backup(u"full", source, options=[u"--name=backup1"])
         # Confirm we actually resumed the previous backup
-        self.assertEqual(len(os.listdir(u"testfiles/output")), 4)
+        self.assertEqual(len(os.listdir(u"{0}/testfiles/output".format(_runtest_dir))), 4)
         # Now make sure everything is byte-for-byte the same once restored
         self.restore()
-        assert not os.system(u"diff -r %s testfiles/restore_out" % source)
+        assert not os.system(u"diff -r {1} {0}/testfiles/restore_out".format(_runtest_dir, source))
 
     def test_split_after_large(self):
         u"""
         If we restart right after a volume that ended with a large
         (multi-block) file, make sure we restart in the right place.
         """
-        source = u'testfiles/largefiles'
+        source = u'{0}/testfiles/largefiles'.format(_runtest_dir)
         self.make_largefiles(count=1, size=1)
         self.backup(u"full", source, options=[u"--volsize=5", u"--name=backup1"])
         # Fake an interruption
@@ -231,17 +232,17 @@
         # 'restart' the backup
         self.backup(u"full", source, options=[u"--volsize=5", u"--name=backup1"])
         # Confirm we actually resumed the previous backup
-        self.assertEqual(len(os.listdir(u"testfiles/output")), 4)
+        self.assertEqual(len(os.listdir(u"{0}/testfiles/output".format(_runtest_dir))), 4)
         # Now make sure everything is byte-for-byte the same once restored
         self.restore()
-        assert not os.system(u"diff -r %s testfiles/restore_out" % source)
+        assert not os.system(u"diff -r %s {0}/testfiles/restore_out".format(_runtest_dir) % source)
 
     def test_split_inside_large(self):
         u"""
         If we restart right after a volume that ended inside of a large
         (multi-block) file, make sure we restart in the right place.
         """
-        source = u'testfiles/largefiles'
+        source = u'{0}/testfiles/largefiles'.format(_runtest_dir)
         self.make_largefiles(count=1, size=3)
         self.backup(u"full", source, options=[u"--name=backup1"])
         # Fake an interruption
@@ -250,7 +251,7 @@
         self.backup(u"full", source, options=[u"--name=backup1"])
         # Now make sure everything is byte-for-byte the same once restored
         self.restore()
-        assert not os.system(u"diff -r %s testfiles/restore_out" % source)
+        assert not os.system(u"diff -r {0} {1}/testfiles/restore_out".format(source, _runtest_dir))
 
     def test_new_file(self):
         u"""
@@ -259,7 +260,7 @@
         (Expected result is to ignore new, ealier files, but pick up later
         ones.)
         """
-        source = u'testfiles/largefiles'
+        source = u'{0}/testfiles/largefiles'.format(_runtest_dir)
         self.make_largefiles(count=1, size=1)
         self.backup(u"full", source, options=[u"--name=backup1"])
         # Fake an interruption
@@ -271,9 +272,9 @@
         self.backup(u"full", source, options=[u"--name=backup1"])
         # Now make sure everything is the same once restored, except 'a'
         self.restore()
-        assert not os.system(u"test ! -e testfiles/restore_out/a")
-        assert not os.system(u"diff %s/file1 testfiles/restore_out/file1" % source)
-        assert not os.system(u"diff %s/z testfiles/restore_out/z" % source)
+        assert not os.system(u"test ! -e {0}/testfiles/restore_out/a".format(_runtest_dir))
+        assert not os.system(u"diff {0}/file1 {1}/testfiles/restore_out/file1".format(source, _runtest_dir))
+        assert not os.system(u"diff {0}/z {1}/testfiles/restore_out/z".format(source, _runtest_dir))
 
     @unittest.skipIf(sys.version_info.major == 2, u"Skip on possible timing error")
     def test_changed_source_dangling_manifest_volume(self):
@@ -284,11 +285,11 @@
         if the source data changes to be small enough to not create a vol3 on
         restart.
         """
-        source = u'testfiles/largefiles'
+        source = u'{0}/testfiles/largefiles'.format(_runtest_dir)
         self.make_largefiles(count=5, size=1)
         self.backup(u"full", source, fail=3)
         # now delete the last volume on remote end and some source files
-        assert not os.system(u"rm testfiles/output/duplicity-full*vol3.difftar*")
+        assert not os.system(u"rm {0}/testfiles/output/duplicity-full*vol3.difftar*".format(_runtest_dir))
         assert not os.system(u"rm %s/file[2345]" % source)
         assert not os.system(u"echo hello > %s/z" % source)
         # finish backup
@@ -303,7 +304,7 @@
         possible that the first chunk of the next file will be skipped unless
         we're careful.
         """
-        source = u'testfiles/largefiles'
+        source = u'{0}/testfiles/largefiles'.format(_runtest_dir)
         self.make_largefiles(count=1)
         self.backup(u"full", source, fail=2)
         # now remove starting source data and make sure we add something after
@@ -313,7 +314,7 @@
         self.backup(u"full", source)
         # and verify we can restore
         self.restore()
-        assert not os.system(u"diff %s/z testfiles/restore_out/z" % source)
+        assert not os.system(u"diff {0}/z {1}/testfiles/restore_out/z".format(source, _runtest_dir))
 
 
 # Note that this class duplicates all the tests in RestartTest
@@ -331,10 +332,10 @@
         https://launchpad.net/bugs/929067
         """
         self.make_largefiles()
-        self.backup(u"full", u"testfiles/largefiles", fail=2)
-        self.backup(u"full", u"testfiles/largefiles")
+        self.backup(u"full", u"{0}/testfiles/largefiles".format(_runtest_dir), fail=2)
+        self.backup(u"full", u"{0}/testfiles/largefiles".format(_runtest_dir))
         # Now check sigtar
-        sigtars = glob.glob(u"testfiles/output/duplicity-full*.sigtar.gz")
+        sigtars = glob.glob(u"{0}/testfiles/output/duplicity-full*.sigtar.gz".format(_runtest_dir))
         self.assertEqual(1, len(sigtars))
         sigtar = sigtars[0]
         output = subprocess.Popen([u"tar", u"t", u"--file=%s" % sigtar], stdout=subprocess.PIPE).communicate()[0]
@@ -359,28 +360,28 @@
             raise Exception(u"Platform %s not supported by tar/gtar." % platform.platform())
 
         # Intial normal backup
-        self.backup(u"full", u"testfiles/blocktartest")
+        self.backup(u"full", u"{0}/testfiles/blocktartest".format(_runtest_dir))
         # Create an exact clone of the snapshot folder in the sigtar already.
         # Permissions and mtime must match.
-        os.mkdir(u"testfiles/snapshot", 0o755)
-        os.utime(u"testfiles/snapshot", (1030384548, 1030384548))
+        os.mkdir(u"{0}/testfiles/snapshot".format(_runtest_dir), 0o755)
+        os.utime(u"{0}/testfiles/snapshot".format(_runtest_dir), (1030384548, 1030384548))
         # Adjust the sigtar.gz file to have a bogus second snapshot/ entry
         # at the beginning.
-        sigtars = glob.glob(u"testfiles/output/duplicity-full*.sigtar.gz")
+        sigtars = glob.glob(u"{0}/testfiles/output/duplicity-full*.sigtar.gz".format(_runtest_dir))
         self.assertEqual(1, len(sigtars))
         sigtar = sigtars[0]
-        self.assertEqual(0, os.system(u"%s c --file=testfiles/snapshot.sigtar -C testfiles snapshot" % (tarcmd,)))
-        self.assertEqual(0, os.system(u"gunzip -c %s > testfiles/full.sigtar" % sigtar))
-        self.assertEqual(0, os.system(u"%s A --file=testfiles/snapshot.sigtar testfiles/full.sigtar" % (tarcmd,)))
-        self.assertEqual(0, os.system(u"gzip testfiles/snapshot.sigtar"))
+        self.assertEqual(0, os.system(u"{0} c --file={1}/testfiles/snapshot.sigtar -C {1}/testfiles snapshot".format(tarcmd, _runtest_dir)))
+        self.assertEqual(0, os.system(u"gunzip -c {1} > {0}/testfiles/full.sigtar".format(_runtest_dir, sigtar)))
+        self.assertEqual(0, os.system(u"{0} A --file={1}/testfiles/snapshot.sigtar {1}/testfiles/full.sigtar".format(tarcmd, _runtest_dir)))
+        self.assertEqual(0, os.system(u"gzip {0}/testfiles/snapshot.sigtar".format(_runtest_dir)))
         os.remove(sigtar)
-        os.rename(u"testfiles/snapshot.sigtar.gz", sigtar)
+        os.rename(u"{0}/testfiles/snapshot.sigtar.gz".format(_runtest_dir), sigtar)
         # Clear cache so our adjusted sigtar will be sync'd back into the cache
-        self.assertEqual(0, os.system(u"rm -r testfiles/cache"))
+        self.assertEqual(0, os.system(u"rm -r {0}/testfiles/cache".format(_runtest_dir)))
         # Try a follow on incremental (which in buggy versions, would create
         # a deleted entry for the base dir)
-        self.backup(u"inc", u"testfiles/blocktartest")
-        self.assertEqual(1, len(glob.glob(u"testfiles/output/duplicity-new*.sigtar.gz")))
+        self.backup(u"inc", u"{0}/testfiles/blocktartest".format(_runtest_dir))
+        self.assertEqual(1, len(glob.glob(u"{0}/testfiles/output/duplicity-new*.sigtar.gz".format(_runtest_dir))))
         # Confirm we can restore it (which in buggy versions, would fail)
         self.restore()
 
diff -Nru duplicity-0.8.18/testing/functional/test_selection.py duplicity-0.8.19/testing/functional/test_selection.py
--- duplicity-0.8.18/testing/functional/test_selection.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/testing/functional/test_selection.py	2021-04-29 18:20:20.000000000 +0000
@@ -1127,8 +1127,8 @@
         self.assertEqual(restored, self.expected_restored_tree)
 
 
-@unittest.skipUnless(sys.getfilesystemencoding().upper() == u"UTF-8",
-                     u"Skipping TestUnicode -- Only tested to work on UTF-8 systems")
+@unittest.skipUnless(platform.platform().startswith(u"Linux"), u"Skip on non-Linux systems")
+@unittest.skipUnless(sys.getfilesystemencoding().upper() == u"UTF-8", u"Skip on non-UTF-8 systems")
 @unittest.skipIf(sys.version_info[:2] < (3, 7), u"Skip on bad unicode handling")
 class TestUnicode(IncludeExcludeFunctionalTest):
     u""" Tests include/exclude options with unicode paths"""
diff -Nru duplicity-0.8.18/testing/functional/test_verify.py duplicity-0.8.19/testing/functional/test_verify.py
--- duplicity-0.8.18/testing/functional/test_verify.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/testing/functional/test_verify.py	2021-04-29 18:20:20.000000000 +0000
@@ -27,6 +27,7 @@
 import os
 import unittest
 
+from testing import _runtest_dir
 from . import CmdError, FunctionalTestCase
 
 
@@ -36,63 +37,63 @@
     """
     def test_verify(self):
         u"""Test that verify (without --compare-data) works in the basic case"""
-        self.backup(u"full", u"testfiles/various_file_types", options=[])
-        self.verify(u'testfiles/various_file_types/executable', file_to_verify=u'executable', options=[])
+        self.backup(u"full", u"{0}/testfiles/various_file_types".format(_runtest_dir), options=[])
+        self.verify(u'{0}/testfiles/various_file_types/executable'.format(_runtest_dir), file_to_verify=u'executable', options=[])
 
     def test_verify_changed_source_file(self):
         u"""Test verify (without --compare-data) gives no error if a source file is changed"""
         # This test was made to pass in fixing Bug #1354880
-        self.backup(u"full", u"testfiles/various_file_types", options=[])
+        self.backup(u"full", u"{0}/testfiles/various_file_types".format(_runtest_dir), options=[])
 
         # Edit source file
-        with open(u'testfiles/various_file_types/executable', u'r+') as f:
+        with open(u'{0}/testfiles/various_file_types/executable'.format(_runtest_dir), u'r+') as f:
             f.write(u'This changes a source file.')
 
         # Test verify for the file
-        self.verify(u'testfiles/various_file_types/executable', file_to_verify=u'executable', options=[])
+        self.verify(u'{0}/testfiles/various_file_types/executable'.format(_runtest_dir), file_to_verify=u'executable', options=[])
 
     def test_verify_changed_source_file_adjust_mtime(self):
         u"""Test verify (without --compare-data) gives no error if a source file is changed and the mtime is changed
         (changing anything about the source files shouldn't matter)"""
 
         # Get the atime and mtime of the file
-        file_info = os.stat(u'testfiles/various_file_types/executable')
+        file_info = os.stat(u'{0}/testfiles/various_file_types/executable'.format(_runtest_dir))
 
         # Set the atime and mtime of the file to the time that we collected, as on some systems
         # the times from a stat call don't match what a utime will set.
-        os.utime(u'testfiles/various_file_types/executable', (file_info.st_atime, file_info.st_mtime))
+        os.utime(u'{0}/testfiles/various_file_types/executable'.format(_runtest_dir), (file_info.st_atime, file_info.st_mtime))
 
-        self.backup(u"full", u"testfiles/various_file_types", options=[])
+        self.backup(u"full", u"{0}/testfiles/various_file_types".format(_runtest_dir), options=[])
 
         # Edit source file
-        with open(u'testfiles/various_file_types/executable', u'r+') as f:
+        with open(u'{0}/testfiles/various_file_types/executable'.format(_runtest_dir), u'r+') as f:
             f.write(u'This changes a source file.')
 
         # Set the atime and mtime for the file back to what it was prior to the edit
-        os.utime(u'testfiles/various_file_types/executable', (file_info.st_atime, file_info.st_mtime))
+        os.utime(u'{0}/testfiles/various_file_types/executable'.format(_runtest_dir), (file_info.st_atime, file_info.st_mtime))
 
         # Test verify for the file
-        self.verify(u'testfiles/various_file_types/executable', file_to_verify=u'executable', options=[])
+        self.verify(u'{0}/testfiles/various_file_types/executable'.format(_runtest_dir), file_to_verify=u'executable', options=[])
 
     def test_verify_compare_data(self):
         u"""Test that verify works in the basic case when the --compare-data option is used"""
-        self.backup(u"full", u"testfiles/various_file_types", options=[])
+        self.backup(u"full", u"{0}/testfiles/various_file_types".format(_runtest_dir), options=[])
 
         # Test verify for the file with --compare-data
-        self.verify(u'testfiles/various_file_types/executable', file_to_verify=u'executable',
+        self.verify(u'{0}/testfiles/various_file_types/executable'.format(_runtest_dir), file_to_verify=u'executable',
                     options=[u"--compare-data"])
 
     def test_verify_compare_data_changed_source_file(self):
         u"""Test verify with --compare-data gives an error if a source file is changed"""
-        self.backup(u"full", u"testfiles/various_file_types", options=[])
+        self.backup(u"full", u"{0}/testfiles/various_file_types".format(_runtest_dir), options=[])
 
         # Edit source file
-        with open(u'testfiles/various_file_types/executable', u'r+') as f:
+        with open(u'{0}/testfiles/various_file_types/executable'.format(_runtest_dir), u'r+') as f:
             f.write(u'This changes a source file.')
 
         # Test verify for edited file fails with --compare-data
         try:
-            self.verify(u'testfiles/various_file_types/executable', file_to_verify=u'executable',
+            self.verify(u'{0}/testfiles/various_file_types/executable'.format(_runtest_dir), file_to_verify=u'executable',
                         options=[u"--compare-data"])
         except CmdError as e:
             self.assertEqual(e.exit_status, 1, str(e))
@@ -103,23 +104,23 @@
         u"""Test verify with --compare-data gives an error if a source file is changed, even if the mtime is changed"""
 
         # Get the atime and mtime of the file
-        file_info = os.stat(u'testfiles/various_file_types/executable')
+        file_info = os.stat(u'{0}/testfiles/various_file_types/executable'.format(_runtest_dir))
 
         # Set the atime and mtime of the file to the time that we collected, as on some systems
         # the times from a stat call don't match what a utime will set
-        os.utime(u'testfiles/various_file_types/executable', (file_info.st_atime, file_info.st_mtime))
+        os.utime(u'{0}/testfiles/various_file_types/executable'.format(_runtest_dir), (file_info.st_atime, file_info.st_mtime))
 
-        self.backup(u"full", u"testfiles/various_file_types", options=[])
+        self.backup(u"full", u"{0}/testfiles/various_file_types".format(_runtest_dir), options=[])
         # Edit source file
-        with open(u'testfiles/various_file_types/executable', u'r+') as f:
+        with open(u'{0}/testfiles/various_file_types/executable'.format(_runtest_dir), u'r+') as f:
             f.write(u'This changes a source file.')
 
         # Set the atime and mtime for the file back to what it was prior to the edit
-        os.utime(u'testfiles/various_file_types/executable', (file_info.st_atime, file_info.st_mtime))
+        os.utime(u'{0}/testfiles/various_file_types/executable'.format(_runtest_dir), (file_info.st_atime, file_info.st_mtime))
 
         # Test verify for edited file fails with --compare-data
         try:
-            self.verify(u'testfiles/various_file_types/executable', file_to_verify=u'executable',
+            self.verify(u'{0}/testfiles/various_file_types/executable'.format(_runtest_dir), file_to_verify=u'executable',
                         options=[u"--compare-data"])
         except CmdError as e:
             self.assertEqual(e.exit_status, 1, str(e))
@@ -128,16 +129,16 @@
 
     def test_verify_corrupt_archive(self):
         u"""Test verify (without --compare-data) gives an error if the archive is corrupted"""
-        self.backup(u"full", u"testfiles/various_file_types", options=[])
-        output_files = os.listdir(u"testfiles/output")
+        self.backup(u"full", u"{0}/testfiles/various_file_types".format(_runtest_dir), options=[])
+        output_files = os.listdir(u"{0}/testfiles/output".format(_runtest_dir))
         archives = [elem for elem in output_files if u"vol" in elem]
         for archive in archives:
             # Edit source file
-            with open(u"testfiles/output/" + archive, u'r+') as f:
+            with open(u"{0}/testfiles/output/".format(_runtest_dir) + archive, u'r+') as f:
                 f.write(u'This writes text into each archive file to corrupt it.')
         # Test verify for the file
         try:
-            self.verify(u'testfiles/various_file_types/executable', file_to_verify=u'executable', options=[])
+            self.verify(u'{0}/testfiles/various_file_types/executable'.format(_runtest_dir), file_to_verify=u'executable', options=[])
         except CmdError as e:
             # Should return a 21 error code for "hash mismatch"
             self.assertEqual(e.exit_status, 21, str(e))
@@ -146,16 +147,16 @@
 
     def test_verify_corrupt_archive_compare_data(self):
         u"""Test verify with --compare-data gives an error if the archive is corrupted"""
-        self.backup(u"full", u"testfiles/various_file_types", options=[])
-        output_files = os.listdir(u"testfiles/output")
+        self.backup(u"full", u"{0}/testfiles/various_file_types".format(_runtest_dir), options=[])
+        output_files = os.listdir(u"{0}/testfiles/output".format(_runtest_dir))
         archives = [elem for elem in output_files if u"vol" in elem]
         for archive in archives:
             # Edit source file
-            with open(u"testfiles/output/" + archive, u'r+') as f:
+            with open(u"{0}/testfiles/output/".format(_runtest_dir) + archive, u'r+') as f:
                 f.write(u'This writes text into each archive file to corrupt it.')
         # Test verify for the file
         try:
-            self.verify(u'testfiles/various_file_types/executable', file_to_verify=u'executable',
+            self.verify(u'{0}/testfiles/various_file_types/executable'.format(_runtest_dir), file_to_verify=u'executable',
                         options=[u"--compare-data"])
         except CmdError as e:
             # Should return a 21 error code for "hash mismatch"
diff -Nru duplicity-0.8.18/testing/__init__.py duplicity-0.8.19/testing/__init__.py
--- duplicity-0.8.18/testing/__init__.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/testing/__init__.py	2021-04-29 18:20:20.000000000 +0000
@@ -22,7 +22,10 @@
 from future import standard_library
 standard_library.install_aliases()
 
+import gettext
 import os
+import platform
+import subprocess
 import sys
 import time
 import unittest
@@ -30,12 +33,27 @@
 from duplicity import backend
 from duplicity import config
 from duplicity import log
+from duplicity import util
+
+util.start_debugger()
+
+if sys.version_info.major >= 3:
+    gettext.install(u'duplicity', names=[u'ngettext'])
+else:
+    gettext.install(u'duplicity', names=[u'ngettext'], unicode=True)  # pylint: disable=unexpected-keyword-arg
 
 _testing_dir = os.path.dirname(os.path.abspath(__file__))
 _top_dir = os.path.dirname(_testing_dir)
 _overrides_dir = os.path.join(_testing_dir, u'overrides')
 _bin_dir = os.path.join(_testing_dir, u'overrides', u'bin')
 
+if platform.system().startswith(u'Darwin'):
+    # Use temp space from getconf, never /tmp
+    _runtest_dir = subprocess.check_output([u'getconf', u'DARWIN_USER_TEMP_DIR'])
+    _runtest_dir = util.fsdecode(_runtest_dir).rstrip().rstrip(u'/')
+else:
+    _runtest_dir = os.getenv(u'TMPDIR', False) or os.getenv(u'TEMP', False) or u'/tmp'
+
 # Adjust python path for duplicity and override modules
 sys.path = [_overrides_dir, _top_dir, _bin_dir] + sys.path
 
@@ -61,10 +79,11 @@
 if sys.version_info.major == 2:
     files = os.listdir(_bin_dir)
     for file in files:
-        if file.endswith(u'.py'):
-            with open(file) as f:
-                print(u"converting %s to python2" % file, file=sys.stderr)
-                f.write(f.read().replace(u"python3", u"python"))
+        print(u"converting %s to python2" % file, file=sys.stderr)
+        with open(os.path.join(_bin_dir, file), u"r") as f:
+            p2 = f.read().replace(u"python3", u"python")
+        with open(os.path.join(_bin_dir, file), u"w") as f:
+            p2 = f.write(p2)
 
 class DuplicityTestCase(unittest.TestCase):
 
@@ -83,21 +102,31 @@
         self.set_config(u'print_statistics', 0)
         backend.import_backends()
 
-        # Have all file references in tests relative to our testing dir
-        os.chdir(_testing_dir)
+        self.remove_testfiles()
+        self.unpack_testfiles()
+
+        # Have all file references in tests relative to our runtest dir
+        os.chdir(_runtest_dir)
 
     def tearDown(self):
         for key in self.savedEnviron:
             self._update_env(key, self.savedEnviron[key])
+
         for key in self.savedConfig:
             setattr(config, key, self.savedConfig[key])
-        assert not os.system(u"rm -rf testfiles")
+
+        self.remove_testfiles()
+
+        os.chdir(_testing_dir)
         super(DuplicityTestCase, self).tearDown()
 
     def unpack_testfiles(self):
-        assert not os.system(u"rm -rf testfiles")
-        assert not os.system(u"tar xzf testfiles.tar.gz > /dev/null 2>&1")
-        assert not os.system(u"mkdir testfiles/output testfiles/cache")
+        assert not os.system(u"rm -rf {0}/testfiles".format(_runtest_dir))
+        assert not os.system(u"tar xzf {0}/testfiles.tar.gz -C {1} > /dev/null 2>&1".format(_testing_dir, _runtest_dir))
+        assert not os.system(u"mkdir {0}/testfiles/output {0}/testfiles/cache".format(_runtest_dir))
+
+    def remove_testfiles(self):
+        assert not os.system(u"rm -rf {0}/testfiles".format(_runtest_dir))
 
     def _update_env(self, key, value):
         if value is not None:
diff -Nru duplicity-0.8.18/testing/manual/bug1893481/testit.sh duplicity-0.8.19/testing/manual/bug1893481/testit.sh
--- duplicity-0.8.18/testing/manual/bug1893481/testit.sh	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/testing/manual/bug1893481/testit.sh	1970-01-01 00:00:00.000000000 +0000
@@ -1,15 +0,0 @@
-#!/bin/sh
-
-export PASSPHRASE=foo
-export PYTHONPATH=../../../
-
-rm -rf /tmp/testdup /tmp/testrest
-
-$PYTHONPATH/bin/duplicity full -v5 data file:///tmp/testdup
-$PYTHONPATH/bin/duplicity list-current-files -v5 file:///tmp/testdup
-$PYTHONPATH/bin/duplicity verify --compare-data -v5 file:///tmp/testdup data
-$PYTHONPATH/bin/duplicity inc -v5 data file:///tmp/testdup
-$PYTHONPATH/bin/duplicity restore -v5 file:///tmp/testdup /tmp/testrest
-
-diff data /tmp/testrest
-echo "diff returned $?"
Binary files /tmp/tmpp2xgismo/fRcrcAZFck/duplicity-0.8.18/testing/manual/bug1893481.tgz and /tmp/tmpp2xgismo/0OuaQ7Mg3P/duplicity-0.8.19/testing/manual/bug1893481.tgz differ
diff -Nru duplicity-0.8.18/testing/manual/bug1919017.json duplicity-0.8.19/testing/manual/bug1919017.json
--- duplicity-0.8.18/testing/manual/bug1919017.json	1970-01-01 00:00:00.000000000 +0000
+++ duplicity-0.8.19/testing/manual/bug1919017.json	2021-04-29 18:20:20.000000000 +0000
@@ -0,0 +1,10 @@
+[
+    {
+        "description": "first drive",
+        "url": "file:///tmp/first_drive"
+    },
+    {
+        "description": "second drive",
+        "url": "file:///tmp/second_drive"
+    }
+]
diff -Nru duplicity-0.8.18/testing/manual/bug1919017.sh duplicity-0.8.19/testing/manual/bug1919017.sh
--- duplicity-0.8.18/testing/manual/bug1919017.sh	1970-01-01 00:00:00.000000000 +0000
+++ duplicity-0.8.19/testing/manual/bug1919017.sh	2021-04-29 18:20:20.000000000 +0000
@@ -0,0 +1,21 @@
+#!/bin/bash
+
+cd `dirname $0`/../..
+
+export PYTHONPATH=`pwd`
+export PASSPHRASE=foo
+
+#export PYDEVD=True
+
+for t in 'mirror' 'stripe'; do
+    for i in $(seq 10); do
+        bin/duplicity --no-encryption full /etc/hosts "multi:///`pwd`/testing/manual/bug1919017.json?mode=$t"
+        sleep 1
+    done
+
+    bin/duplicity --verbosity 9 --no-encryption remove-all-but-n-full 1 "multi:///`pwd`/testing/manual/issue25.json?mode=$t" --force 2>&1 | grep 'failed to delete'
+
+    ls -l /tmp/*_drive
+
+    rm -rf /tmp/*_drive
+done
diff -Nru duplicity-0.8.18/testing/manual/roottest.py duplicity-0.8.19/testing/manual/roottest.py
--- duplicity-0.8.18/testing/manual/roottest.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/testing/manual/roottest.py	2021-04-29 18:20:20.000000000 +0000
@@ -42,7 +42,7 @@
         assert not os.system(u"tar xzf manual/rootfiles.tar.gz > /dev/null 2>&1")
 
     def tearDown(self):
-        assert not os.system(u"rm -rf testfiles tempdir temp2.tar")
+        assert not os.system(u"rm -rf /tmp/testfiles tempdir temp2.tar")
 
     def copyfileobj(self, infp, outfp):
         u"""Copy in fileobj to out, closing afterwards"""
@@ -56,8 +56,8 @@
 
     def deltmp(self):
         u"""Delete temporary directories"""
-        assert not os.system(u"rm -rf testfiles/output")
-        os.mkdir(u"testfiles/output")
+        assert not os.system(u"rm -rf /tmp/testfiles/output")
+        os.mkdir(u"/tmp/testfiles/output")
 
     def get_sel(self, path):
         u"""Get selection iter over the given directory"""
@@ -67,11 +67,11 @@
         u"""Test signatures, diffing, and patching on directory list"""
         assert len(filelist) >= 2
         self.deltmp()
-        assert not os.system(u"cp -pR %s testfiles/output/sequence" %
+        assert not os.system(u"cp -pR %s /tmp/testfiles/output/sequence" %
                              (filelist[0],))
-        seq_path = Path(u"testfiles/output/sequence")
-        sig = Path(u"testfiles/output/sig.tar")
-        diff = Path(u"testfiles/output/diff.tar")
+        seq_path = Path(u"/tmp/testfiles/output/sequence")
+        sig = Path(u"/tmp/testfiles/output/sig.tar")
+        diff = Path(u"/tmp/testfiles/output/diff.tar")
         for dirname in filelist[1:]:
             new_path = Path(dirname)
             diffdir.write_block_iter(
@@ -88,16 +88,16 @@
 
     def test_basic_cycle(self):
         u"""Test cycle on dir with devices, changing uid/gid, etc."""
-        self.total_sequence([u'testfiles/root1', u'testfiles/root2'])
+        self.total_sequence([u'/tmp/testfiles/root1', u'/tmp/testfiles/root2'])
 
     def test_patchdir(self):
         u"""Test changing uid/gid, devices"""
         self.deltmp()
-        os.system(u"cp -pR testfiles/root1 testfiles/output/sequence")
-        seq_path = Path(u"testfiles/output/sequence")
-        new_path = Path(u"testfiles/root2")
-        sig = Path(u"testfiles/output/sig.tar")
-        diff = Path(u"testfiles/output/diff.tar")
+        os.system(u"cp -pR /tmp/testfiles/root1 /tmp/testfiles/output/sequence")
+        seq_path = Path(u"/tmp/testfiles/output/sequence")
+        new_path = Path(u"/tmp/testfiles/root2")
+        sig = Path(u"/tmp/testfiles/output/sig.tar")
+        diff = Path(u"/tmp/testfiles/output/diff.tar")
 
         diffdir.write_block_iter(diffdir.DirSig(self.get_sel(seq_path)), sig)
         deltablock = diffdir.DirDelta(self.get_sel(new_path), sig.open(u"rb"))
@@ -115,9 +115,9 @@
     def test_patchdir2(self):
         u"""Again test files we don't have access to, this time Tar_WriteSig"""
         self.deltmp()
-        sig_path = Path(u"testfiles/output/sig.sigtar")
-        tar_path = Path(u"testfiles/output/tar.tar")
-        basis_path = Path(u"testfiles/root1")
+        sig_path = Path(u"/tmp/testfiles/output/sig.sigtar")
+        tar_path = Path(u"/tmp/testfiles/output/tar.tar")
+        basis_path = Path(u"/tmp/testfiles/root1")
 
         deltablock = diffdir.DirFull_WriteSig(self.get_sel(basis_path),
                                               sig_path.open(u"wb"))
diff -Nru duplicity-0.8.18/testing/manual/run-coverage.sh duplicity-0.8.19/testing/manual/run-coverage.sh
--- duplicity-0.8.18/testing/manual/run-coverage.sh	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/testing/manual/run-coverage.sh	2021-04-29 18:20:20.000000000 +0000
@@ -28,7 +28,7 @@
 ./setup.py build_ext
 cd -
 
-#${SUDO} tar xzf testfiles.tar.gz
+#${SUDO} tar xzf testfiles.tar.gz -C /tmp
 
 ARGS=`python <<EOF
 import sys
@@ -46,7 +46,7 @@
     ${CMD} 2>&1 | grep -v "unsafe ownership"
 done
 
-#${SUDO} rm -rf testfiles tempdir temp2.tar
+#${SUDO} rm -rf /tmp/testfiles tempdir temp2.tar
 
 # Gen the coverage maps by file
 python -m trace --report --missing --file=counts --coverdir=coverage
diff -Nru duplicity-0.8.18/testing/manual/stdin_test.sh duplicity-0.8.19/testing/manual/stdin_test.sh
--- duplicity-0.8.18/testing/manual/stdin_test.sh	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/testing/manual/stdin_test.sh	2021-04-29 18:20:20.000000000 +0000
@@ -15,7 +15,7 @@
 RESTOREDIR=$TESTDIR/dup_restore
 mkdir $RESTOREDIR
 
-tar -C $SOURCEDIR -xvf testfiles.tar.gz testfiles/select 
+tar -C $SOURCEDIR -xvf testfiles.tar.gz /tmp/testfiles/select 
 
 DUPLICITY_CMD="../bin/duplicity"
 export PYTHONPATH=../
@@ -27,10 +27,10 @@
 echo "==========="
 TEST1="Test with exclude-globbing"
 echo "${TEST1}"
-echo "+ $SOURCEDIR/testfiles/select/1/1" > $TESTDIR/exclude.txt
-echo "- $SOURCEDIR/testfiles/select/1/2" >> $TESTDIR/exclude.txt
-echo "+ $SOURCEDIR/testfiles/select/1/3" >> $TESTDIR/exclude.txt
-echo "- $SOURCEDIR/testfiles/select/3" >> $TESTDIR/exclude.txt
+echo "+ $SOURCEDIR//tmp/testfiles/select/1/1" > $TESTDIR/exclude.txt
+echo "- $SOURCEDIR//tmp/testfiles/select/1/2" >> $TESTDIR/exclude.txt
+echo "+ $SOURCEDIR//tmp/testfiles/select/1/3" >> $TESTDIR/exclude.txt
+echo "- $SOURCEDIR//tmp/testfiles/select/3" >> $TESTDIR/exclude.txt
 echo "- $SOURCEDIR/**" >> $TESTDIR/exclude.txt
 
 $DUPLICITY_CMD --exclude-globbing-filelist $TESTDIR/exclude.txt $SOURCEDIR file://$TARGETDIR
@@ -51,12 +51,12 @@
 mkdir $SOURCEDIR
 mkdir $TARGETDIR
 mkdir $RESTOREDIR
-tar -C $SOURCEDIR -xvf testfiles.tar.gz testfiles/select 
+tar -C $SOURCEDIR -xvf testfiles.tar.gz /tmp/testfiles/select 
 
-echo "+ $SOURCEDIR/testfiles/select/1/1" > $TESTDIR/exclude.txt
-echo "- $SOURCEDIR/testfiles/select/1/2" >> $TESTDIR/exclude.txt
-echo "+ $SOURCEDIR/testfiles/select/1/3" >> $TESTDIR/exclude.txt
-echo "- $SOURCEDIR/testfiles/select/3" >> $TESTDIR/exclude.txt
+echo "+ $SOURCEDIR//tmp/testfiles/select/1/1" > $TESTDIR/exclude.txt
+echo "- $SOURCEDIR//tmp/testfiles/select/1/2" >> $TESTDIR/exclude.txt
+echo "+ $SOURCEDIR//tmp/testfiles/select/1/3" >> $TESTDIR/exclude.txt
+echo "- $SOURCEDIR//tmp/testfiles/select/3" >> $TESTDIR/exclude.txt
 echo "- $SOURCEDIR/**" >> $TESTDIR/exclude.txt
 
 $DUPLICITY_CMD --exclude-filelist $TESTDIR/exclude.txt $SOURCEDIR file://$TARGETDIR
@@ -77,12 +77,12 @@
 mkdir $SOURCEDIR
 mkdir $TARGETDIR
 mkdir $RESTOREDIR
-tar -C $SOURCEDIR -xvf testfiles.tar.gz testfiles/select 
+tar -C $SOURCEDIR -xvf testfiles.tar.gz /tmp/testfiles/select 
 
-echo "+ $SOURCEDIR/testfiles/select/1/1" > $TESTDIR/exclude.txt
-echo "- $SOURCEDIR/testfiles/select/1/2" >> $TESTDIR/exclude.txt
-echo "+ $SOURCEDIR/testfiles/select/1/3" >> $TESTDIR/exclude.txt
-echo "- $SOURCEDIR/testfiles/select/3" >> $TESTDIR/exclude.txt
+echo "+ $SOURCEDIR//tmp/testfiles/select/1/1" > $TESTDIR/exclude.txt
+echo "- $SOURCEDIR//tmp/testfiles/select/1/2" >> $TESTDIR/exclude.txt
+echo "+ $SOURCEDIR//tmp/testfiles/select/1/3" >> $TESTDIR/exclude.txt
+echo "- $SOURCEDIR//tmp/testfiles/select/3" >> $TESTDIR/exclude.txt
 echo "- $SOURCEDIR/**" >> $TESTDIR/exclude.txt
 
 cat $TESTDIR/exclude.txt | $DUPLICITY_CMD --exclude-filelist-stdin $SOURCEDIR file://$TARGETDIR
@@ -102,12 +102,12 @@
 mkdir $SOURCEDIR
 mkdir $TARGETDIR
 mkdir $RESTOREDIR
-tar -C $SOURCEDIR -xvf testfiles.tar.gz testfiles/select 
+tar -C $SOURCEDIR -xvf testfiles.tar.gz /tmp/testfiles/select 
 
-echo "+ $SOURCEDIR/testfiles/select/1/1" > $TESTDIR/exclude.txt
-echo "- $SOURCEDIR/testfiles/select/1/2" >> $TESTDIR/exclude.txt
-echo "+ $SOURCEDIR/testfiles/select/1/3" >> $TESTDIR/exclude.txt
-echo "- $SOURCEDIR/testfiles/select/3" >> $TESTDIR/exclude.txt
+echo "+ $SOURCEDIR//tmp/testfiles/select/1/1" > $TESTDIR/exclude.txt
+echo "- $SOURCEDIR//tmp/testfiles/select/1/2" >> $TESTDIR/exclude.txt
+echo "+ $SOURCEDIR//tmp/testfiles/select/1/3" >> $TESTDIR/exclude.txt
+echo "- $SOURCEDIR//tmp/testfiles/select/3" >> $TESTDIR/exclude.txt
 echo "- $SOURCEDIR/**" >> $TESTDIR/exclude.txt
 
 $DUPLICITY_CMD $SOURCEDIR file://$TARGETDIR
@@ -127,12 +127,12 @@
 mkdir $SOURCEDIR
 mkdir $TARGETDIR
 mkdir $RESTOREDIR
-tar -C $SOURCEDIR -xvf testfiles.tar.gz testfiles/select 
+tar -C $SOURCEDIR -xvf testfiles.tar.gz /tmp/testfiles/select 
 
-echo "+ $SOURCEDIR/testfiles/select/1/1" > $TESTDIR/exclude.txt
-echo "- $SOURCEDIR/testfiles/select/1/2" >> $TESTDIR/exclude.txt
-echo "+ $SOURCEDIR/testfiles/select/1/3" >> $TESTDIR/exclude.txt
-echo "- $SOURCEDIR/testfiles/select/3" >> $TESTDIR/exclude.txt
+echo "+ $SOURCEDIR//tmp/testfiles/select/1/1" > $TESTDIR/exclude.txt
+echo "- $SOURCEDIR//tmp/testfiles/select/1/2" >> $TESTDIR/exclude.txt
+echo "+ $SOURCEDIR//tmp/testfiles/select/1/3" >> $TESTDIR/exclude.txt
+echo "- $SOURCEDIR//tmp/testfiles/select/3" >> $TESTDIR/exclude.txt
 echo "- $SOURCEDIR/**" >> $TESTDIR/exclude.txt
 
 cat $TESTDIR/exclude.txt | $DUPLICITY_CMD --exclude-filelist /dev/stdin $SOURCEDIR file://$TARGETDIR
@@ -152,12 +152,12 @@
 mkdir $SOURCEDIR
 mkdir $TARGETDIR
 mkdir $RESTOREDIR
-tar -C $SOURCEDIR -xvf testfiles.tar.gz testfiles/select 
+tar -C $SOURCEDIR -xvf testfiles.tar.gz /tmp/testfiles/select 
 
-echo "+ $SOURCEDIR/testfiles/select/1/1" > $TESTDIR/include.txt
-echo "- $SOURCEDIR/testfiles/select/1/2" >> $TESTDIR/include.txt
-echo "+ $SOURCEDIR/testfiles/select/1/3" >> $TESTDIR/include.txt
-echo "- $SOURCEDIR/testfiles/select/3" >> $TESTDIR/include.txt
+echo "+ $SOURCEDIR//tmp/testfiles/select/1/1" > $TESTDIR/include.txt
+echo "- $SOURCEDIR//tmp/testfiles/select/1/2" >> $TESTDIR/include.txt
+echo "+ $SOURCEDIR//tmp/testfiles/select/1/3" >> $TESTDIR/include.txt
+echo "- $SOURCEDIR//tmp/testfiles/select/3" >> $TESTDIR/include.txt
 echo "- $SOURCEDIR/**" >> $TESTDIR/include.txt
 
 cat $TESTDIR/include.txt | $DUPLICITY_CMD --include-filelist-stdin $SOURCEDIR file://$TARGETDIR
@@ -177,12 +177,12 @@
 mkdir $SOURCEDIR
 mkdir $TARGETDIR
 mkdir $RESTOREDIR
-tar -C $SOURCEDIR -xvf testfiles.tar.gz testfiles/select 
+tar -C $SOURCEDIR -xvf testfiles.tar.gz /tmp/testfiles/select 
 
-echo "+ $SOURCEDIR/testfiles/select/1/1" > $TESTDIR/include.txt
-echo "- $SOURCEDIR/testfiles/select/1/2" >> $TESTDIR/include.txt
-echo "+ $SOURCEDIR/testfiles/select/1/3" >> $TESTDIR/include.txt
-echo "- $SOURCEDIR/testfiles/select/3" >> $TESTDIR/include.txt
+echo "+ $SOURCEDIR//tmp/testfiles/select/1/1" > $TESTDIR/include.txt
+echo "- $SOURCEDIR//tmp/testfiles/select/1/2" >> $TESTDIR/include.txt
+echo "+ $SOURCEDIR//tmp/testfiles/select/1/3" >> $TESTDIR/include.txt
+echo "- $SOURCEDIR//tmp/testfiles/select/3" >> $TESTDIR/include.txt
 echo "- $SOURCEDIR/**" >> $TESTDIR/include.txt
 
 cat $TESTDIR/include.txt | $DUPLICITY_CMD --include-filelist /dev/stdin $SOURCEDIR file://$TARGETDIR
diff -Nru duplicity-0.8.18/testing/overrides/bin/tahoe duplicity-0.8.19/testing/overrides/bin/tahoe
--- duplicity-0.8.18/testing/overrides/bin/tahoe	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/testing/overrides/bin/tahoe	2021-04-29 18:20:20.000000000 +0000
@@ -4,11 +4,18 @@
 from future import standard_library
 standard_library.install_aliases()
 
+import os
 import subprocess
 import sys
 
+from testing import _runtest_dir
+
+our_path = u'{0}/testfiles'.format(_runtest_dir)
+nodes = [n for n in our_path.split(os.path.sep) if n]
+tahoe_path = nodes[0] + u':' + os.path.sep.join(nodes[1:])
+
 cmd = []
 for arg in sys.argv[1:]:
-    cmd.append(arg.replace('testfiles:', 'testfiles/'))
+    cmd.append(arg.replace(tahoe_path, our_path))
 
 sys.exit(subprocess.call(cmd))
diff -Nru duplicity-0.8.18/testing/overrides/gettext.py duplicity-0.8.19/testing/overrides/gettext.py
--- duplicity-0.8.18/testing/overrides/gettext.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/testing/overrides/gettext.py	1970-01-01 00:00:00.000000000 +0000
@@ -1,36 +0,0 @@
-# -*- Mode:Python; indent-tabs-mode:nil; tab-width:4; encoding:utf8 -*-
-#
-# Copyright 2014 Michael Terry <mike@mterry.name>
-#
-# This file is part of duplicity.
-#
-# Duplicity is free software; you can redistribute it and/or modify it
-# under the terms of the GNU General Public License as published by the
-# Free Software Foundation; either version 2 of the License, or (at your
-# option) any later version.
-#
-# Duplicity is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with duplicity; if not, write to the Free Software Foundation,
-# Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-
-# This is just a small override to the system gettext.py which allows us to
-# always return a string with fancy unicode characters, which will notify us
-# if we ever get a unicode->ascii translation by accident.
-
-
-def install(*args, **kwargs):  # pylint: disable=unused-argument
-    ZWSP = u"​"  # ZERO WIDTH SPACE, basically an invisible space separator
-    import sys
-    if sys.version_info.major >= 3:
-        import builtins
-        b = builtins
-    else:
-        import __builtin__  # pylint: disable=import-error
-        b = __builtin__
-    b.__dict__[u'_'] = lambda x: x + ZWSP
-    b.__dict__[u'ngettext'] = lambda one, more, n: one + ZWSP if n == 1 else more + ZWSP
diff -Nru duplicity-0.8.18/testing/test_code.py duplicity-0.8.19/testing/test_code.py
--- duplicity-0.8.18/testing/test_code.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/testing/test_code.py	2021-04-29 18:20:20.000000000 +0000
@@ -46,10 +46,14 @@
     def run_checker(self, cmd, returncodes=[0]):
         process = subprocess.Popen(cmd,
                                    stdout=subprocess.PIPE,
-                                   stderr=subprocess.PIPE)
+                                   stderr=subprocess.PIPE,
+                                   universal_newlines=True)
         output = process.communicate()[0]
+        if len(output):
+            for line in output.split(u'\n'):
+                print(line, file=sys.stderr)
+            output = u""
         self.assertTrue(process.returncode in returncodes, output)
-        self.assertEqual(b"", output, output)
 
     @skipCodeTest
     def test_2to3(self):
@@ -78,6 +82,7 @@
         u"""Pylint test (requires pylint to be installed to pass)"""
         self.run_checker([
             u"pylint",
+            u"--rcfile=" + os.path.join(_top_dir, u"pylintrc"),
             os.path.join(_top_dir, u'duplicity'),
             os.path.join(_top_dir, u'bin/duplicity'),
             os.path.join(_top_dir, u'bin/rdiffdir')])
diff -Nru duplicity-0.8.18/testing/unit/test_backend_instance.py duplicity-0.8.19/testing/unit/test_backend_instance.py
--- duplicity-0.8.18/testing/unit/test_backend_instance.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/testing/unit/test_backend_instance.py	2021-04-29 18:20:20.000000000 +0000
@@ -33,19 +33,21 @@
 from duplicity.errors import BackendException
 import duplicity.backend
 
+from testing import _runtest_dir
+from testing import _testing_dir
 
 class BackendInstanceBase(UnitTestCase):
 
     def setUp(self):
         UnitTestCase.setUp(self)
-        assert not os.system(u"rm -rf testfiles")
-        os.makedirs(u'testfiles')
+        assert not os.system(u"rm -rf {0}/testfiles".format(_runtest_dir))
+        os.makedirs(u'{0}/testfiles'.format(_runtest_dir))
         self.backend = None
-        self.local = path.Path(u'testfiles/local')
+        self.local = path.Path(u'{0}/testfiles/local'.format(_runtest_dir))
         self.local.writefileobj(io.BytesIO(b"hello"))
 
     def tearDown(self):
-        assert not os.system(u"rm -rf testfiles")
+        assert not os.system(u"rm -rf {0}/testfiles".format(_runtest_dir))
         if self.backend is None:
             return
         if hasattr(self.backend, u'_close'):
@@ -55,7 +57,7 @@
         if self.backend is None:
             return
         self.backend._put(self.local, b'file-a')
-        getfile = path.Path(u'testfiles/getfile')
+        getfile = path.Path(u'{0}/testfiles/getfile'.format(_runtest_dir))
         self.backend._get(b'file-a', getfile)
         self.assertTrue(self.local.compare_data(getfile))
 
@@ -89,7 +91,7 @@
             return
         self.backend._put(self.local, b'file-a')
         self.backend._delete(b'file-a')
-        self.assertEqual(self.backend._list(), [])
+        self.assertFalse(b'file-a' in self.backend._list())
 
     def test_delete_missing(self):
         if self.backend is None:
@@ -128,14 +130,14 @@
         if not hasattr(self.backend, u'_move'):
             return
 
-        copy = path.Path(u'testfiles/copy')
+        copy = path.Path(u'{0}/testfiles/copy'.format(_runtest_dir))
         self.local.copy(copy)
 
         self.backend._move(self.local, b'file-a')
         self.assertTrue(b'file-a' in self.backend._list())
         self.assertFalse(self.local.exists())
 
-        getfile = path.Path(u'testfiles/getfile')
+        getfile = path.Path(u'{0}/testfiles/getfile'.format(_runtest_dir))
         self.backend._get(b'file-a', getfile)
         self.assertTrue(copy.compare_data(getfile))
 
@@ -181,16 +183,17 @@
 class LocalBackendTest(BackendInstanceBase):
     def setUp(self):
         super(LocalBackendTest, self).setUp()
-        url = u'file://testfiles/output'
+        url = u'file://{0}/testfiles/output'.format(_runtest_dir)
         self.backend = duplicity.backend.get_backend_object(url)
         self.assertEqual(self.backend.__class__.__name__, u'LocalBackend')
 
 
 # TODO: Add par2-specific tests here, to confirm that we can recover
+@unittest.skipIf(not util.which(u'lftp'), u"lftp not installed")
 class Par2BackendTest(BackendInstanceBase):
     def setUp(self):
         super(Par2BackendTest, self).setUp()
-        url = u'par2+file://testfiles/output'
+        url = u'par2+file://{0}/testfiles/output'.format(_runtest_dir)
         self.backend = duplicity.backend.get_backend_object(url)
         self.assertEqual(self.backend.__class__.__name__, u'Par2Backend')
 
@@ -199,8 +202,8 @@
 # class RsyncBackendTest(BackendInstanceBase):
 #     def setUp(self):
 #         super(RsyncBackendTest, self).setUp()
-#         os.makedirs(u'testfiles/output')  # rsync needs it to exist first
-#         url = u'rsync://localhost:2222//%s/testfiles/output' % os.getcwd()
+#         os.makedirs(u'{0}/testfiles/output')  # rsync needs it to exist first
+#         url = u'rsync://localhost:2222//%s/{0}/testfiles/output' % os.getcwd()
 #         self.backend = duplicity.backend.get_backend_object(url)
 #         self.assertEqual(self.backend.__class__.__name__, u'RsyncBackend')
 
@@ -208,8 +211,8 @@
 class TahoeBackendTest(BackendInstanceBase):
     def setUp(self):
         super(TahoeBackendTest, self).setUp()
-        os.makedirs(u'testfiles/output')
-        url = u'tahoe://testfiles/output'
+        os.makedirs(u'{0}/testfiles/output'.format(_runtest_dir))
+        url = u'tahoe://{0}/testfiles/output'.format(_runtest_dir)
         self.backend = duplicity.backend.get_backend_object(url)
         self.assertEqual(self.backend.__class__.__name__, u'TAHOEBackend')
 
@@ -218,27 +221,29 @@
 #  class HSIBackendTest(BackendInstanceBase):
 #      def setUp(self):
 #          super(HSIBackendTest, self).setUp()
-#          os.makedirs(u'testfiles/output')
+#          os.makedirs(u'{0}/testfiles/output')
 #          # hostname is ignored...  Seemingly on purpose
-#          url = u'hsi://hostname%s/testfiles/output' % os.getcwd()
+#          url = u'hsi://hostname%s/{0}/testfiles/output' % os.getcwd()
 #          self.backend = duplicity.backend.get_backend_object(url)
 #          self.assertEqual(self.backend.__class__.__name__, u'HSIBackend')
 
 
+@unittest.skipIf(not util.which(u'lftp'), u"lftp not installed")
 class FTPBackendTest(BackendInstanceBase):
     def setUp(self):
         super(FTPBackendTest, self).setUp()
-        os.makedirs(u'testfiles/output')
-        url = u'ftp://user:pass@hostname/testfiles/output'
+        os.makedirs(u'{0}/testfiles/output'.format(_runtest_dir))
+        url = u'ftp://user:pass@hostname/{0}/testfiles/output'.format(_runtest_dir)
         self.backend = duplicity.backend.get_backend_object(url)
         self.assertEqual(self.backend.__class__.__name__, u'LFTPBackend')
 
 
+@unittest.skipIf(not util.which(u'lftp'), u"lftp not installed")
 class FTPSBackendTest(BackendInstanceBase):
     def setUp(self):
         super(FTPSBackendTest, self).setUp()
-        os.makedirs(u'testfiles/output')
-        url = u'ftps://user:pass@hostname/testfiles/output'
+        os.makedirs(u'{0}/testfiles/output'.format(_runtest_dir))
+        url = u'ftps://user:pass@hostname/{0}/testfiles/output'.format(_runtest_dir)
         self.backend = duplicity.backend.get_backend_object(url)
         self.assertEqual(self.backend.__class__.__name__, u'LFTPBackend')
 
@@ -247,7 +252,7 @@
 class RCloneBackendTest(BackendInstanceBase):
     def setUp(self):
         super(RCloneBackendTest, self).setUp()
-        os.makedirs(u'testfiles/output')
-        url = u'rclone://duptest:/%s/testfiles/output' % os.getcwd()
+        os.makedirs(u'{0}/testfiles/output'.format(_runtest_dir))
+        url = u'rclone://duptest:/%s/{0}/testfiles/output'.format(_runtest_dir)
         self.backend = duplicity.backend.get_backend_object(url)
         self.assertEqual(self.backend.__class__.__name__, u'RcloneBackend')
diff -Nru duplicity-0.8.18/testing/unit/test_collections.py duplicity-0.8.19/testing/unit/test_collections.py
--- duplicity-0.8.18/testing/unit/test_collections.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/testing/unit/test_collections.py	2021-04-29 18:20:20.000000000 +0000
@@ -35,6 +35,7 @@
 from duplicity import dup_time
 from duplicity import gpg
 from duplicity import path
+from testing import _runtest_dir
 
 filename_list1 = [b"duplicity-full.2002-08-17T16:17:01-07:00.manifest.gpg",
                   b"duplicity-full.2002-08-17T16:17:01-07:00.vol1.difftar.gpg",
@@ -83,16 +84,16 @@
 
         self.unpack_testfiles()
 
-        col_test_dir = path.Path(u"testfiles/collectionstest")
+        col_test_dir = path.Path(u"{0}/testfiles/collectionstest".format(_runtest_dir))
         archive_dir_path = col_test_dir.append(u"archive_dir")
         self.set_config(u'archive_dir_path', archive_dir_path)
-        self.archive_dir_backend = backend.get_backend(u"file://testfiles/collectionstest"
+        self.archive_dir_backend = backend.get_backend(u"file://{0}/testfiles/collectionstest".format(_runtest_dir) +
                                                        u"/archive_dir")
 
         self.real_backend = backend.get_backend(u"file://%s/%s" %
                                                 (col_test_dir.uc_name, u"remote_dir"))
-        self.output_dir = path.Path(u"testfiles/output")  # used as a temp directory
-        self.output_dir_backend = backend.get_backend(u"file://testfiles/output")
+        self.output_dir = path.Path(u"{0}/testfiles/output".format(_runtest_dir))  # used as a temp directory
+        self.output_dir_backend = backend.get_backend(u"file://{0}/testfiles/output".format(_runtest_dir))
 
     def set_gpg_profile(self):
         u"""Set gpg profile to standard "foobar" sym"""
@@ -102,7 +103,7 @@
         u"""Test basic backup chain construction"""
         random.shuffle(filename_list1)
         cs = dup_collections.CollectionsStatus(None, config.archive_dir_path, u"full")
-        chains, orphaned, incomplete = cs.get_backup_chains(filename_list1)          
+        chains, orphaned, incomplete = cs.get_backup_chains(filename_list1)
         if len(chains) != 1 or len(orphaned) != 0:
             print(chains)
             print(orphaned)
@@ -169,7 +170,7 @@
     def sigchain_fileobj_check_list(self, chain):
         u"""Make sure the list of file objects in chain has right contents
 
-        The contents of the testfiles/collectiontest/remote_dir have
+        The contents of the /tmp/testfiles/collectiontest/remote_dir have
         to be coordinated with this test.
 
         """
@@ -194,7 +195,7 @@
 
     def get_filelist2_cs(self):
         u"""Return set CollectionsStatus object from filelist 2"""
-        # Set up testfiles/output with files from filename_list2
+        # Set up /tmp/testfiles/output with files from filename_list2
         for filename in filename_list2:
             p = self.output_dir.append(filename)
             p.touch()
@@ -215,7 +216,7 @@
                       b"duplicity-full.2002-08-15T01:01:01-07:00.vol1.difftar.gpg",
                       b"duplicity-inc.2000-08-17T16:17:01-07:00.to.2000-08-18T00:04:30-07:00.manifest.gpg",
                       b"duplicity-inc.2000-08-17T16:17:01-07:00.to.2000-08-18T00:04:30-07:00.vol1.difftar.gpg"]
-        local_received_list, remote_received_list = cs.get_extraneous()          
+        local_received_list, remote_received_list = cs.get_extraneous()
         errors = []
         for filename in remote_received_list:
             if filename not in right_list:
diff -Nru duplicity-0.8.18/testing/unit/test_diffdir.py duplicity-0.8.19/testing/unit/test_diffdir.py
--- duplicity-0.8.18/testing/unit/test_diffdir.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/testing/unit/test_diffdir.py	2021-04-29 18:20:20.000000000 +0000
@@ -33,6 +33,7 @@
 from duplicity import tarfile
 from duplicity import util
 from duplicity.path import *  # pylint: disable=unused-wildcard-import,redefined-builtin
+from testing import _runtest_dir
 from . import UnitTestCase
 
 
@@ -55,13 +56,14 @@
 
     def testsig(self):
         u"""Test producing tar signature of various file types"""
-        select = selection.Select(Path(u"testfiles/various_file_types"))
+        select = selection.Select(Path(u"{0}/testfiles/various_file_types".format(_runtest_dir)))
         select.set_iter()
         sigtar = diffdir.SigTarBlockIter(select)
-        diffdir.write_block_iter(sigtar, u"testfiles/output/sigtar")
+        diffdir.write_block_iter(sigtar, u"{0}/testfiles/output/sigtar".format(_runtest_dir))
 
         i = 0
-        for tarinfo in tarfile.TarFile(u"testfiles/output/sigtar", u"r"):              i += 1
+        for tarinfo in tarfile.TarFile(u"{0}/testfiles/output/sigtar".format(_runtest_dir), u"r"):
+            i += 1
         assert i >= 5, u"There should be at least 5 files in sigtar"
 
     def empty_diff_schema(self, dirname):
@@ -69,54 +71,55 @@
         select = selection.Select(Path(dirname))
         select.set_iter()
         sigtar = diffdir.SigTarBlockIter(select)
-        diffdir.write_block_iter(sigtar, u"testfiles/output/sigtar")
+        diffdir.write_block_iter(sigtar, u"{0}/testfiles/output/sigtar".format(_runtest_dir))
 
-        sigtar_fp = open(u"testfiles/output/sigtar", u"rb")
+        sigtar_fp = open(u"{0}/testfiles/output/sigtar".format(_runtest_dir), u"rb")
         select2 = selection.Select(Path(dirname))
         select2.set_iter()
         diffdir.write_block_iter(diffdir.DirDelta(select2, sigtar_fp),
-                                 u"testfiles/output/difftar")
+                                 u"{0}/testfiles/output/difftar".format(_runtest_dir))
 
-        size = os.stat(u"testfiles/output/difftar").st_size
+        size = os.stat(u"{0}/testfiles/output/difftar".format(_runtest_dir)).st_size
         assert size == 0 or size == 10240, size  # 10240 is size of one record
         if size != 0:
-            fin = open(u"testfiles/output/difftar", u"rb")
+            fin = open(u"{0}/testfiles/output/difftar".format(_runtest_dir), u"rb")
             diff_buf = fin.read()
             assert not fin.close()
             assert diff_buf == b'\0' * 10240
 
     def test_empty_diff(self):
         u"""Test producing a diff against same sig; should be len 0"""
-        self.empty_diff_schema(u"testfiles/various_file_types")
+        self.empty_diff_schema(u"{0}/testfiles/various_file_types".format(_runtest_dir))
 
-        select = selection.Select(Path(u"testfiles/various_file_types"))
+        select = selection.Select(Path(u"{0}/testfiles/various_file_types".format(_runtest_dir)))
         select.set_iter()
         sigtar = diffdir.SigTarBlockIter(select)
-        diffdir.write_block_iter(sigtar, u"testfiles/output/sigtar")
+        diffdir.write_block_iter(sigtar, u"{0}/testfiles/output/sigtar".format(_runtest_dir))
 
-        sigtar_fp = open(u"testfiles/output/sigtar", u"rb")
-        select2 = selection.Select(Path(u"testfiles/various_file_types"))
+        sigtar_fp = open(u"{0}/testfiles/output/sigtar".format(_runtest_dir), u"rb")
+        select2 = selection.Select(Path(u"{0}/testfiles/various_file_types".format(_runtest_dir)))
         select2.set_iter()
         diffdir.write_block_iter(diffdir.DirDelta(select2, sigtar_fp),
-                                 u"testfiles/output/difftar")
+                                 u"{0}/testfiles/output/difftar".format(_runtest_dir))
 
-        size = os.stat(u"testfiles/output/difftar").st_size
+        size = os.stat(u"{0}/testfiles/output/difftar".format(_runtest_dir)).st_size
+    
     def test_empty_diff2(self):
         u"""Test producing diff against directories of special files"""
-        self.empty_diff_schema(u"testfiles/special_cases/neg_mtime")
-        self.empty_diff_schema(u"testfiles/special_cases/no_uname")
+        self.empty_diff_schema(u"{0}/testfiles/special_cases/neg_mtime".format(_runtest_dir))
+        self.empty_diff_schema(u"{0}/testfiles/special_cases/no_uname".format(_runtest_dir))
 
     def test_diff(self):
         u"""Test making a diff"""
-        sel1 = selection.Select(Path(u"testfiles/dir1"))
+        sel1 = selection.Select(Path(u"{0}/testfiles/dir1".format(_runtest_dir)))
         diffdir.write_block_iter(diffdir.SigTarBlockIter(sel1.set_iter()),
-                                 u"testfiles/output/dir1.sigtar")
+                                 u"{0}/testfiles/output/dir1.sigtar".format(_runtest_dir))
 
-        sigtar_fp = open(u"testfiles/output/dir1.sigtar", u"rb")
-        sel2 = selection.Select(Path(u"testfiles/dir2"))
+        sigtar_fp = open(u"{0}/testfiles/output/dir1.sigtar".format(_runtest_dir), u"rb")
+        sel2 = selection.Select(Path(u"{0}/testfiles/dir2".format(_runtest_dir)))
         delta_tar = diffdir.DirDelta(sel2.set_iter(), sigtar_fp)
         diffdir.write_block_iter(delta_tar,
-                                 u"testfiles/output/dir1dir2.difftar")
+                                 u"{0}/testfiles/output/dir1dir2.difftar".format(_runtest_dir))
 
         changed_files = [u"diff/changeable_permission",
                          u"diff/regular_file",
@@ -124,7 +127,7 @@
                          u"deleted/deleted_file",
                          u"snapshot/directory_to_file",
                          u"snapshot/file_to_directory/"]
-        for tarinfo in tarfile.TarFile(u"testfiles/output/dir1dir2.difftar",
+        for tarinfo in tarfile.TarFile(u"{0}/testfiles/output/dir1dir2.difftar".format(_runtest_dir),
                                        u"r"):
             tiname = util.get_tarinfo_name(tarinfo)
             if tiname in changed_files:
@@ -135,30 +138,30 @@
     def test_diff2(self):
         u"""Another diff test - this one involves multivol support
         (requires rdiff to be installed to pass)"""
-        sel1 = selection.Select(Path(u"testfiles/dir2"))
+        sel1 = selection.Select(Path(u"{0}/testfiles/dir2".format(_runtest_dir)))
         diffdir.write_block_iter(diffdir.SigTarBlockIter(sel1.set_iter()),
-                                 u"testfiles/output/dir2.sigtar")
+                                 u"{0}/testfiles/output/dir2.sigtar".format(_runtest_dir))
 
-        sigtar_fp = open(u"testfiles/output/dir2.sigtar", u"rb")
-        sel2 = selection.Select(Path(u"testfiles/dir3"))
+        sigtar_fp = open(u"{0}/testfiles/output/dir2.sigtar".format(_runtest_dir), u"rb")
+        sel2 = selection.Select(Path(u"{0}/testfiles/dir3".format(_runtest_dir)))
         delta_tar = diffdir.DirDelta(sel2.set_iter(), sigtar_fp)
         diffdir.write_block_iter(delta_tar,
-                                 u"testfiles/output/dir2dir3.difftar")
+                                 u"{0}/testfiles/output/dir2dir3.difftar".format(_runtest_dir))
 
         buffer = b""
-        tf = tarfile.TarFile(u"testfiles/output/dir2dir3.difftar", u"r")
+        tf = tarfile.TarFile(u"{0}/testfiles/output/dir2dir3.difftar".format(_runtest_dir), u"r")
         for tarinfo in tf:
             if tarinfo.name.startswith(r"multivol_diff/"):
                 buffer += tf.extractfile(tarinfo).read()
         assert 3000000 < len(buffer) < 4000000
-        fout = open(u"testfiles/output/largefile.delta", u"wb")
+        fout = open(u"{0}/testfiles/output/largefile.delta".format(_runtest_dir), u"wb")
         fout.write(buffer)
         fout.close()
-        assert not os.system(u"rdiff patch testfiles/dir2/largefile "
-                             u"testfiles/output/largefile.delta "
-                             u"testfiles/output/largefile.patched")
-        dir3large = open(u"testfiles/dir3/largefile", u"rb").read()
-        patchedlarge = open(u"testfiles/output/largefile.patched", u"rb").read()
+        assert not os.system(u"rdiff patch {0}/testfiles/dir2/largefile ".format(_runtest_dir) +
+                             u"{0}/testfiles/output/largefile.delta ".format(_runtest_dir) +
+                             u"{0}/testfiles/output/largefile.patched".format(_runtest_dir))
+        dir3large = open(u"{0}/testfiles/dir3/largefile".format(_runtest_dir), u"rb").read()
+        patchedlarge = open(u"{0}/testfiles/output/largefile.patched".format(_runtest_dir), u"rb").read()
         assert dir3large == patchedlarge
 
     def test_dirdelta_write_sig(self):
@@ -168,11 +171,11 @@
         those produced by DirDelta_WriteSig and other methods.
 
         """
-        deltadir1 = Path(u"testfiles/output/dir.deltatar1")
-        deltadir2 = Path(u"testfiles/output/dir.deltatar2")
-        cur_full_sigs = Path(u"testfiles/output/fullsig.dir1")
+        deltadir1 = Path(u"{0}/testfiles/output/dir.deltatar1".format(_runtest_dir))
+        deltadir2 = Path(u"{0}/testfiles/output/dir.deltatar2".format(_runtest_dir))
+        cur_full_sigs = Path(u"{0}/testfiles/output/fullsig.dir1".format(_runtest_dir))
 
-        cur_dir = Path(u"testfiles/dir1")
+        cur_dir = Path(u"{0}/testfiles/dir1".format(_runtest_dir))
         get_sel = lambda cur_dir: selection.Select(cur_dir).set_iter()
         diffdir.write_block_iter(diffdir.SigTarBlockIter(get_sel(cur_dir)),
                                  cur_full_sigs)
@@ -181,14 +184,14 @@
         for dirname in [u'dir2', u'dir3', u'dir4']:
             # print "Processing ", dirname
             old_dir = cur_dir
-            cur_dir = Path(u"testfiles/" + dirname)
+            cur_dir = Path(u"{0}/testfiles/".format(_runtest_dir) + dirname)
 
             old_full_sigs = cur_full_sigs
-            cur_full_sigs = Path(u"testfiles/output/fullsig." + dirname)
+            cur_full_sigs = Path(u"{0}/testfiles/output/fullsig.".format(_runtest_dir) + dirname)
 
-            delta1 = Path(u"testfiles/output/delta1." + dirname)
-            delta2 = Path(u"testfiles/output/delta2." + dirname)
-            incsig = Path(u"testfiles/output/incsig." + dirname)
+            delta1 = Path(u"{0}/testfiles/output/delta1.".format(_runtest_dir) + dirname)
+            delta2 = Path(u"{0}/testfiles/output/delta2.".format(_runtest_dir) + dirname)
+            incsig = Path(u"{0}/testfiles/output/incsig.".format(_runtest_dir) + dirname)
 
             # Write old-style delta to deltadir1
             diffdir.write_block_iter(diffdir.DirDelta(get_sel(cur_dir),
diff -Nru duplicity-0.8.18/testing/unit/test_globmatch.py duplicity-0.8.19/testing/unit/test_globmatch.py
--- duplicity-0.8.18/testing/unit/test_globmatch.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/testing/unit/test_globmatch.py	2021-04-29 18:20:20.000000000 +0000
@@ -30,6 +30,7 @@
 from . import UnitTestCase
 from duplicity.globmatch import *  # pylint: disable=unused-wildcard-import,redefined-builtin
 from duplicity.path import *  # pylint: disable=unused-wildcard-import,redefined-builtin
+from testing import _runtest_dir
 from mock import patch
 
 
@@ -107,9 +108,9 @@
     def test_glob_scans_parent_directories(self):
         u"""Test glob scans parent"""
         self.assertEqual(
-            inc_sel_dir(u"testfiles/parent/sub", u"testfiles/parent"), 2)
+            inc_sel_dir(u"{0}/testfiles/parent/sub".format(_runtest_dir), u"{0}/testfiles/parent".format(_runtest_dir)), 2)
         self.assertEqual(
-            inc_sel_dir(u"testfiles/select2/3/3sub2", u"testfiles/select2/3"), 2)
+            inc_sel_dir(u"{0}/testfiles/select2/3/3sub2".format(_runtest_dir), u"{0}/testfiles/select2/3".format(_runtest_dir)), 2)
 
     def test_double_asterisk_include(self):
         u"""Test a few globbing patterns, including **"""
@@ -162,19 +163,19 @@
         # Bug #1624725
         # https://bugs.launchpad.net/duplicity/+bug/1624725
         self.assertEqual(inc_sel_file(
-            u"testfiles/select2/1/1sub1/1sub1sub1/",
-            u"testfiles/select2/1/1sub1/1sub1sub1/1sub1sub1_file.txt"), 1)
+            u"{0}/testfiles/select2/1/1sub1/1sub1sub1/".format(_runtest_dir),
+            u"{0}/testfiles/select2/1/1sub1/1sub1sub1/1sub1sub1_file.txt".format(_runtest_dir)), 1)
 
     def test_included_files_are_matched_slash_2_parents(self):
         u"""Test that duplicity will scan parent of glob/"""
         # Bug #1624725
         # https://bugs.launchpad.net/duplicity/+bug/1624725
         self.assertEqual(inc_sel_dir(
-            u"testfiles/select2/1/1sub1/1sub1sub1/",
-            u"testfiles/select2/1/1sub1/1sub1sub1"), 1)
+            u"{0}/testfiles/select2/1/1sub1/1sub1sub1/".format(_runtest_dir),
+            u"{0}/testfiles/select2/1/1sub1/1sub1sub1".format(_runtest_dir)), 1)
         self.assertEqual(inc_sel_dir(
-            u"testfiles/select2/1/1sub1/1sub1sub1/",
-            u"testfiles/select2/1/1sub1"), 2)
+            u"{0}/testfiles/select2/1/1sub1/1sub1sub1/".format(_runtest_dir),
+            u"{0}/testfiles/select2/1/1sub1".format(_runtest_dir)), 2)
 
     def test_included_files_are_matched_slash_wildcard(self):
         u"""Test that files within an included folder are matched with /"""
@@ -184,7 +185,7 @@
 
     def test_slash_matches_everything(self):
         u"""Test / matches everything"""
-        self.assertEqual(inc_sel_dir(u"/", u"/tmp/testfiles/select/1/2"), 1)
+        self.assertEqual(inc_sel_dir(u"/", u"/tmp/{0}/testfiles/select/1/2".format(_runtest_dir)), 1)
         self.assertEqual(inc_sel_dir(u"/", u"/test/random/path"), 1)
         self.assertEqual(exc_sel_dir(u"/", u"/test/random/path"), 0)
         self.assertEqual(inc_sel_dir(u"/", u"/"), 1)
@@ -209,17 +210,17 @@
 
     def test_simple_trailing_slash_match(self):
         u"""Test that a normal folder string ending in / matches that path"""
-        self.assertEqual(inc_sel_dir(u"testfiles/select/1/2/1/",
-                                     u"testfiles/select/1/2/1"), 1)
+        self.assertEqual(inc_sel_dir(u"{0}/testfiles/select/1/2/1/".format(_runtest_dir),
+                                     u"{0}/testfiles/select/1/2/1".format(_runtest_dir)), 1)
 
     def test_double_asterisk_string_slash(self):
         u"""Test string starting with ** and ending in /"""
-        self.assertEqual(inc_sel_dir(u"**/1/2/", u"testfiles/select/1/2"), 1)
+        self.assertEqual(inc_sel_dir(u"**/1/2/", u"{0}/testfiles/select/1/2".format(_runtest_dir)), 1)
 
     def test_string_double_asterisk_string_slash(self):
         u"""Test string ** string /"""
-        self.assertEqual(inc_sel_dir(u"testfiles**/2/",
-                                     u"testfiles/select/1/2"), 1)
+        self.assertEqual(inc_sel_dir(u"{0}/testfiles**/2/".format(_runtest_dir),
+                                     u"{0}/testfiles/select/1/2".format(_runtest_dir)), 1)
 
 
 class TestDoubleAsterisk(UnitTestCase):
diff -Nru duplicity-0.8.18/testing/unit/test_gpg.py duplicity-0.8.19/testing/unit/test_gpg.py
--- duplicity-0.8.18/testing/unit/test_gpg.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/testing/unit/test_gpg.py	2021-04-29 18:20:20.000000000 +0000
@@ -35,6 +35,7 @@
 
 from duplicity import gpg
 from duplicity import path
+from testing import _runtest_dir
 from . import UnitTestCase
 
 
@@ -48,14 +49,14 @@
 
     def gpg_cycle(self, s, profile=None):
         u"""Test encryption/decryption cycle on string s"""
-        epath = path.Path(u"testfiles/output/encrypted_file")
+        epath = path.Path(u"{0}/testfiles/output/encrypted_file".format(_runtest_dir))
         if not profile:
             profile = self.default_profile
         encrypted_file = gpg.GPGFile(1, epath, profile)
         encrypted_file.write(s)
         encrypted_file.close()
 
-        epath2 = path.Path(u"testfiles/output/encrypted_file")
+        epath2 = path.Path(u"{0}/testfiles/output/encrypted_file".format(_runtest_dir))
         decrypted_file = gpg.GPGFile(0, epath2, profile)
         dec_buf = decrypted_file.read()
         decrypted_file.close()
@@ -109,7 +110,7 @@
                                          sign_key=self.sign_key,
                                          recipients=[self.encrypt_key1])
 
-        epath = path.Path(u"testfiles/output/encrypted_file")
+        epath = path.Path(u"{0}/testfiles/output/encrypted_file".format(_runtest_dir))
         encrypted_signed_file = gpg.GPGFile(1, epath, signing_profile)
         encrypted_signed_file.write(plaintext)
         encrypted_signed_file.close()
@@ -128,7 +129,7 @@
                                          sign_key=self.sign_key,
                                          hidden_recipients=[self.encrypt_key1])
 
-        epath = path.Path(u"testfiles/output/encrypted_file")
+        epath = path.Path(u"{0}/testfiles/output/encrypted_file".format(_runtest_dir))
         encrypted_signed_file = gpg.GPGFile(1, epath, signing_profile)
         encrypted_signed_file.write(plaintext)
         encrypted_signed_file.close()
@@ -146,27 +147,27 @@
         gwfh = GPGWriteFile_Helper()
         profile = gpg.GPGProfile(passphrase=u"foobar")
         for i in range(10):
-            gpg.GPGWriteFile(gwfh, u"testfiles/output/gpgwrite.gpg",
+            gpg.GPGWriteFile(gwfh, u"{0}/testfiles/output/gpgwrite.gpg".format(_runtest_dir),
                              profile, size=size)
-            # print os.stat("testfiles/output/gpgwrite.gpg").st_size-size
-            assert size - 64 * 1024 <= os.stat(u"testfiles/output/gpgwrite.gpg").st_size <= size + 64 * 1024
+            # print os.stat("/tmp/testfiles/output/gpgwrite.gpg").st_size-size
+            assert size - 64 * 1024 <= os.stat(u"{0}/testfiles/output/gpgwrite.gpg".format(_runtest_dir)).st_size <= size + 64 * 1024
         gwfh.set_at_end()
-        gpg.GPGWriteFile(gwfh, u"testfiles/output/gpgwrite.gpg",
+        gpg.GPGWriteFile(gwfh, u"{0}/testfiles/output/gpgwrite.gpg".format(_runtest_dir),
                          profile, size=size)
-        # print os.stat("testfiles/output/gpgwrite.gpg").st_size
+        # print os.stat("/tmp/testfiles/output/gpgwrite.gpg").st_size
 
     def test_GzipWriteFile(self):
         u"""Test GzipWriteFile"""
         size = 400 * 1000
         gwfh = GPGWriteFile_Helper()
         for i in range(10):
-            gpg.GzipWriteFile(gwfh, u"testfiles/output/gzwrite.gz",
+            gpg.GzipWriteFile(gwfh, u"{0}/testfiles/output/gzwrite.gz".format(_runtest_dir),
                               size=size)
-            # print os.stat("testfiles/output/gzwrite.gz").st_size-size
-            assert size - 64 * 1024 <= os.stat(u"testfiles/output/gzwrite.gz").st_size <= size + 64 * 1024
+            # print os.stat("/tmp/testfiles/output/gzwrite.gz").st_size-size
+            assert size - 64 * 1024 <= os.stat(u"{0}/testfiles/output/gzwrite.gz".format(_runtest_dir)).st_size <= size + 64 * 1024
         gwfh.set_at_end()
-        gpg.GzipWriteFile(gwfh, u"testfiles/output/gzwrite.gz", size=size)
-        # print os.stat("testfiles/output/gzwrite.gz").st_size
+        gpg.GzipWriteFile(gwfh, u"{0}/testfiles/output/gzwrite.gz".format(_runtest_dir), size=size)
+        # print os.stat("/tmp/testfiles/output/gzwrite.gz").st_size
 
 
 class GPGWriteHelper2(object):
@@ -214,7 +215,7 @@
         self.unpack_testfiles()
 
     def test_sha(self):
-        testhash = gpg.get_hash(u"SHA1", path.Path(u"testfiles/various_file_types/regular_file"))
+        testhash = gpg.get_hash(u"SHA1", path.Path(u"{0}/testfiles/various_file_types/regular_file".format(_runtest_dir)))
         assert testhash == u"886d722999862724e1e62d0ac51c468ee336ef8e", testhash
 
 
diff -Nru duplicity-0.8.18/testing/unit/test_patchdir.py duplicity-0.8.19/testing/unit/test_patchdir.py
--- duplicity-0.8.18/testing/unit/test_patchdir.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/testing/unit/test_patchdir.py	2021-04-29 18:20:20.000000000 +0000
@@ -28,6 +28,7 @@
 
 import io
 import os
+import platform
 import unittest
 
 from duplicity import diffdir
@@ -37,6 +38,7 @@
 from duplicity import librsync
 from duplicity.lazy import *  # pylint: disable=unused-wildcard-import,redefined-builtin
 from duplicity.path import *  # pylint: disable=unused-wildcard-import,redefined-builtin
+from testing import _runtest_dir
 from . import UnitTestCase
 
 
@@ -59,9 +61,9 @@
 
     def test_total(self):
         u"""Test cycle on dirx"""
-        self.total_sequence([u'testfiles/dir1',
-                             u'testfiles/dir2',
-                             u'testfiles/dir3'])
+        self.total_sequence([u'{0}/testfiles/dir1'.format(_runtest_dir),
+                             u'{0}/testfiles/dir2'.format(_runtest_dir),
+                             u'{0}/testfiles/dir3'.format(_runtest_dir)])
 
     def get_sel(self, path):
         u"""Get selection iter over the given directory"""
@@ -70,9 +72,9 @@
     def total_sequence(self, filelist):
         u"""Test signatures, diffing, and patching on directory list"""
         assert len(filelist) >= 2
-        sig = Path(u"testfiles/output/sig.tar")
-        diff = Path(u"testfiles/output/diff.tar")
-        seq_path = Path(u"testfiles/output/sequence")
+        sig = Path(u"{0}/testfiles/output/sig.tar".format(_runtest_dir))
+        diff = Path(u"{0}/testfiles/output/diff.tar".format(_runtest_dir))
+        seq_path = Path(u"{0}/testfiles/output/sequence".format(_runtest_dir))
         new_path, old_path = None, None  # set below in for loop
 
         # Write initial full backup to diff.tar
@@ -96,7 +98,7 @@
         def get_fileobjs():
             u"""Return iterator yielding open fileobjs of tar files"""
             for i in range(1, 4):
-                p = Path(u"testfiles/blocktartest/test%d.tar" % i)
+                p = Path(u"{0}/testfiles/blocktartest/test{1}.tar".format(_runtest_dir, i))
                 fp = p.open(u"rb")
                 yield fp
                 fp.close()
@@ -117,8 +119,8 @@
 
             # file object will be empty, and tarinfo will have path
             # "snapshot/../warning-security-error"
-            assert not os.system(u"cat /dev/null >testfiles/output/file")
-            path = Path(b"testfiles/output/file")
+            assert not os.system(u"cat /dev/null > {0}/testfiles/output/file".format(_runtest_dir))
+            path = Path(u"{0}/testfiles/output/file".format(_runtest_dir))
             path.index = (b"diff", b"..", b"warning-security-error")
             ti = path.get_tarinfo()
             fp = io.StringIO(u"")
@@ -126,13 +128,13 @@
 
             tf.close()
 
-        make_bad_tar(b"testfiles/output/bad.tar")
-        os.mkdir(u"testfiles/output/temp")
+        make_bad_tar(u"{0}/testfiles/output/bad.tar".format(_runtest_dir))
+        os.mkdir(u"{0}/testfiles/output/temp".format(_runtest_dir))
 
         self.assertRaises(patchdir.PatchDirException, patchdir.Patch,
-                          Path(u"testfiles/output/temp"),
-                          open(u"testfiles/output/bad.tar", u"rb"))
-        assert not Path(u"testfiles/output/warning-security-error").exists()
+                          Path(u"{0}/testfiles/output/temp".format(_runtest_dir)),
+                          open(u"{0}/testfiles/output/bad.tar".format(_runtest_dir), u"rb"))
+        assert not Path(u"{0}/testfiles/output/warning-security-error".format(_runtest_dir)).exists()
 
 
 class index(object):
@@ -201,8 +203,8 @@
         self.check_output()
 
     def check_output(self):
-        u"""Make sure testfiles/output exists"""
-        out = Path(u"testfiles/output")
+        u"""Make {0}/testfiles/output exists"""
+        out = Path(u"{0}/testfiles/output".format(_runtest_dir))
         if not (out.exists() and out.isdir()):
             out.mkdir()
         self.out = out
@@ -280,6 +282,17 @@
         try_seq(seq4, [ss])
         try_seq(seq5, seq1)
 
+    # TODO: fix test_patch_seq2ropath for macOS, maybe others.
+    #       Fails under tox, pytest, and pydevd
+    #----------
+    #     def testseq(seq, perms, buf):
+    #         result = patchdir.patch_seq2ropath(seq)
+    # >       assert result.getperms() == perms, (result.getperms(), perms)
+    # E       AssertionError: ('501:0 600', '501:20 600')
+    # E       assert '501:0 600' == '501:20 600'
+    # E         - 501:0 600
+    # E         + 501:20 600
+    @unittest.skipUnless(platform.platform().startswith(u"Linux"), u"Skip on non-Linux systems")
     def test_patch_seq2ropath(self):
         u"""Test patching sequence"""
         def testseq(seq, perms, buf):
diff -Nru duplicity-0.8.18/testing/unit/test_path.py duplicity-0.8.19/testing/unit/test_path.py
--- duplicity-0.8.18/testing/unit/test_path.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/testing/unit/test_path.py	2021-04-29 18:20:20.000000000 +0000
@@ -27,6 +27,7 @@
 import unittest
 
 from duplicity.path import *  # pylint: disable=unused-wildcard-import,redefined-builtin
+from testing import _runtest_dir
 from . import UnitTestCase
 
 
@@ -38,17 +39,17 @@
 
     def test_deltree(self):
         u"""Test deleting a tree"""
-        assert not os.system(u"cp -pR testfiles/deltree testfiles/output")
-        p = Path(u"testfiles/output")
+        assert not os.system(u"cp -pR {0}/testfiles/deltree {0}/testfiles/output".format(_runtest_dir).format(_runtest_dir))
+        p = Path(u"{0}/testfiles/output".format(_runtest_dir))
         assert p.isdir()
         p.deltree()
         assert not p.type, p.type
 
 #      def test_compare(self):
 #         """Test directory comparisons"""
-#         assert not os.system("cp -pR testfiles/dir1 testfiles/output")
-#         assert Path("testfiles/dir1").compare_recursive(Path("testfiles/output"), 1)
-#         assert not Path("testfiles/dir1").compare_recursive(Path("testfiles/dir2"), 1)
+#         assert not os.system("cp -pR /tmp/testfiles/dir1 /tmp/testfiles/output")
+#         assert Path("/tmp/testfiles/dir1").compare_recursive(Path("/tmp/testfiles/output"), 1)
+#         assert not Path("/tmp/testfiles/dir1").compare_recursive(Path("/tmp/testfiles/dir2"), 1)
 
     def test_quote(self):
         u"""Test path quoting"""
@@ -81,7 +82,7 @@
 
     def test_compare_verbose(self):
         u"""Run compare_verbose on a few files"""
-        vft = Path(u"testfiles/various_file_types")
+        vft = Path(u"{0}/testfiles/various_file_types".format(_runtest_dir))
         assert vft.compare_verbose(vft)
         reg_file = vft.append(u"regular_file")
         assert not vft.compare_verbose(reg_file)
diff -Nru duplicity-0.8.18/testing/unit/test_selection.py duplicity-0.8.19/testing/unit/test_selection.py
--- duplicity-0.8.18/testing/unit/test_selection.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/testing/unit/test_selection.py	2021-04-29 18:20:20.000000000 +0000
@@ -26,6 +26,7 @@
 standard_library.install_aliases()
 
 import io
+import platform
 import unittest
 
 from duplicity.selection import *  # pylint: disable=unused-wildcard-import,redefined-builtin
@@ -872,8 +873,9 @@
                         (u"--exclude", u"testfiles/select2/**")],
                        self.expected_restored_tree)
 
-    def test_unicode_paths_non_globbing(self):
-        u"""Test functional test test_unicode_paths_non_globbing as a unittest"""
+    @unittest.skipUnless(platform.platform().startswith(u"Linux"), u"Skip on non-Linux systems")
+    def _paths_non_globbing(self):
+        u"""Test functional test _paths_non_globbing as a unittest"""
         self.root = Path(u"testfiles/select-unicode")
         self.ParseTest([(u"--exclude", u"testfiles/select-unicode/прыклад/пример/例/Παράδειγμα/उदाहरण.txt"),
                         (u"--exclude", u"testfiles/select-unicode/прыклад/пример/例/Παράδειγμα/דוגמא.txt"),
diff -Nru duplicity-0.8.18/testing/unit/test_statistics.py duplicity-0.8.19/testing/unit/test_statistics.py
--- duplicity-0.8.18/testing/unit/test_statistics.py	2021-01-09 17:50:18.000000000 +0000
+++ duplicity-0.8.19/testing/unit/test_statistics.py	2021-04-29 18:20:20.000000000 +0000
@@ -28,6 +28,7 @@
 from . import UnitTestCase
 from duplicity import path
 from duplicity.statistics import *  # pylint: disable=redefined-builtin, unused-wildcard-import
+from testing import _runtest_dir
 
 
 class StatsObjTest(UnitTestCase):
@@ -134,7 +135,7 @@
 
     def test_write_path(self):
         u"""Test reading and writing of statistics object"""
-        p = path.Path(u"testfiles/statstest")
+        p = path.Path(u"{0}/testfiles/statstest".format(_runtest_dir))
         if p.exists():
             p.delete()
         s = StatsObj()