Merge lp:~fo0bar/turku/turku-api-cleanup into lp:turku/turku-api

[Ryan Finnie]

Mega-noop cleanup

This is the minimum required for:
- tox test suite with all passing tests
- black-managed formatting
- Shippable sdist module

It is intended as a base for the other MPs, so they don't have to e.g. establish tests/*, or worry about about existing failing flake8, or worry about how to add additional optional modules.

[🤖 Canonical IS Merge Bot (canonical-is-mergebot)]

This merge proposal is being monitored by mergebot. Change the status to Approved to merge.

[lp:~fo0bar/turku/turku-api-cleanup]

65. By Ryan Finnie on 2020-06-21

Mega-noop cleanup

- Add setup.py
  - This is a Django application, but treating it as a full Python
    module helps with tox testing
- Sort imports
- Create MANIFEST.in so `setup.py sdist` produces usable tarballs
- Create stub tests
- Add tox.ini
- Add blank requirements.txt
- Add Makefile
- make black
- Update .bzrignore
- Remove blank turku_api/tests.py
- Clean up flake8:
  - Ignore local_settings/local_urls import * F401/F403
  - Ignore wsgi.py import E402
  - Fix urls.py 'django.conf.urls.include' imported but unused

[Stuart Bishop (stub)]

Yup, same deal as the other two turku cleanup branches.

review: Approve

[🤖 Canonical IS Merge Bot (canonical-is-mergebot)]

Change successfully merged at revision 65

=== modified file '.bzrignore'
--- .bzrignore	2015-03-26 05:04:41 +0000
+++ .bzrignore	2020-06-21 23:58:30 +0000
@@ -1,4 +1,64 @@
-*.pyc
 db.sqlite3
 turku_api/local_settings.py
 turku_api/local_urls.py
+MANIFEST
+.pybuild/
+.pytest_cache/
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*,cover
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
 
=== added file 'MANIFEST.in'
--- MANIFEST.in	1970-01-01 00:00:00 +0000
+++ MANIFEST.in	2020-06-21 23:58:30 +0000
@@ -0,0 +1,9 @@
+include Makefile
+include manage.py
+include MANIFEST.in
+include README.md
+include requirements.txt
+include scripts/turku_health
+include tests/*.py
+include tox.ini
+include turku_api/templates/admin/*.html
 
=== added file 'Makefile'
--- Makefile	1970-01-01 00:00:00 +0000
+++ Makefile	2020-06-21 23:58:30 +0000
@@ -0,0 +1,28 @@
+PYTHON := python3
+
+all: build
+
+build:
+	$(PYTHON) setup.py build
+
+lint:
+	$(PYTHON) -mtox -e flake8
+
+test:
+	$(PYTHON) -mtox
+
+test-quick:
+	$(PYTHON) -mtox -e black,flake8,pytest-quick
+
+black-check:
+	$(PYTHON) -mtox -e black
+
+black:
+	$(PYTHON) -mblack $(CURDIR)
+
+install: build
+	$(PYTHON) setup.py install
+
+clean:
+	$(PYTHON) setup.py clean
+	$(RM) -r build MANIFEST
 
=== added file 'requirements.txt'
=== added file 'setup.py'
--- setup.py	1970-01-01 00:00:00 +0000
+++ setup.py	2020-06-21 23:58:30 +0000
@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+
+# Turku backups - API application
+# Copyright 2015-2020 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published by
+# the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from setuptools import setup
+
+
+setup(
+    name="turku_api",
+    description="Turku backups - API application",
+    author="Ryan Finnie",
+    url="https://launchpad.net/turku",
+    python_requires="~=3.4",
+    packages=["turku_api"],
+)
 
=== added directory 'tests'
=== added file 'tests/__init__.py'
=== added file 'tests/test_stub.py'
--- tests/test_stub.py	1970-01-01 00:00:00 +0000
+++ tests/test_stub.py	2020-06-21 23:58:30 +0000
@@ -0,0 +1,8 @@
+import unittest
+import warnings
+
+
+class TestStub(unittest.TestCase):
+    def test_stub(self):
+        # pytest doesn't like a tests/ with no tests
+        warnings.warn("Remove this file once unit tests are added")
 
=== added file 'tox.ini'
--- tox.ini	1970-01-01 00:00:00 +0000
+++ tox.ini	2020-06-21 23:58:30 +0000
@@ -0,0 +1,38 @@
+[tox]
+envlist = black, flake8, pytest
+
+[testenv]
+basepython = python
+
+[testenv:black]
+commands = python -mblack --check .
+deps = black
+
+[testenv:flake8]
+commands = python -mflake8
+deps = flake8
+
+[testenv:pytest]
+commands = python -mpytest --cov=turku_api --cov-report=term-missing
+deps = pytest
+       pytest-cov
+       -r{toxinidir}/requirements.txt
+
+[testenv:pytest-quick]
+commands = python -mpytest -m "not slow"
+deps = pytest
+       -r{toxinidir}/requirements.txt
+
+[flake8]
+exclude =
+    .git,
+    __pycache__,
+    .tox,
+# TODO: remove C901 once complexity is reduced
+ignore = C901,E203,E231,W503
+max-line-length = 120
+max-complexity = 10
+
+[pytest]
+markers =
+    slow
 
=== modified file 'turku_api/admin.py'
--- turku_api/admin.py	2020-05-06 02:41:37 +0000
+++ turku_api/admin.py	2020-06-21 23:58:30 +0000
@@ -14,38 +14,39 @@
 # License along with this program.  If not, see
 # <http://www.gnu.org/licenses/>.
 
+import datetime
+
 from django import forms
 from django.contrib import admin
-from turku_api.models import Machine, Source, Auth, Storage, BackupLog, FilterSet
+from django.contrib.humanize.templatetags.humanize import naturaltime
+from django.utils import timezone
 from django.utils.html import format_html
-from django.utils import timezone
-from django.contrib.humanize.templatetags.humanize import naturaltime
+
 try:
     from django.urls import reverse  # 1.10+
 except ModuleNotFoundError:
     from django.core.urlresolvers import reverse  # pre-1.10
-import datetime
+
+from turku_api.models import Auth, BackupLog, FilterSet, Machine, Source, Storage
 
 
 def get_admin_change_link(obj, name=None):
     url = reverse(
-        'admin:%s_%s_change' % (obj._meta.app_label, obj._meta.model_name),
-        args=(obj.id,)
+        "admin:%s_%s_change" % (obj._meta.app_label, obj._meta.model_name),
+        args=(obj.id,),
     )
     if not name:
         name = obj
-    return format_html(
-        '<a href="{}">{}</a>'.format(url, name)
-    )
+    return format_html('<a href="{}">{}</a>'.format(url, name))
 
 
 def human_si(v, begin=0):
-    p = ('', 'Ki', 'Mi', 'Gi', 'Ti', 'Pi', 'Ei', 'Zi', 'Yi')
+    p = ("", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi", "Yi")
     i = begin
     while v >= 1024.0:
         v = int(v / 10.24) / 100.0
         i += 1
-    return '%g %sB' % (v, p[i])
+    return "%g %sB" % (v, p[i])
 
 
 def human_time(t):
@@ -58,58 +59,62 @@
 
 
 class CustomModelAdmin(admin.ModelAdmin):
-    change_form_template = 'admin/custom_change_form.html'
+    change_form_template = "admin/custom_change_form.html"
 
     def render_change_form(self, request, context, *args, **kwargs):
         # Build a list of related children objects and their counts
         # so they may be linked to in the admin interface
         related_links = []
-        if 'object_id' in context and hasattr(self.model._meta, 'get_fields'):
+        if "object_id" in context and hasattr(self.model._meta, "get_fields"):
             related_objs = [
-                f for f in self.model._meta.get_fields()
-                if (f.one_to_many or f.one_to_one)
-                and f.auto_created and not f.concrete
+                f
+                for f in self.model._meta.get_fields()
+                if (f.one_to_many or f.one_to_one) and f.auto_created and not f.concrete
             ]
             for obj in related_objs:
-                count = obj.related_model.objects.filter(**{obj.field.name: context['object_id']}).count()
+                count = obj.related_model.objects.filter(
+                    **{obj.field.name: context["object_id"]}
+                ).count()
                 if count > 0:
                     related_links.append((obj, obj.related_model._meta, count))
-        context.update({'related_links': related_links})
+        context.update({"related_links": related_links})
 
-        return super(CustomModelAdmin, self).render_change_form(request, context, *args, **kwargs)
+        return super(CustomModelAdmin, self).render_change_form(
+            request, context, *args, **kwargs
+        )
 
 
 class MachineAdminForm(forms.ModelForm):
     class Meta:
         model = Machine
-        fields = '__all__'
+        fields = "__all__"
 
     def __init__(self, *args, **kwargs):
         super(MachineAdminForm, self).__init__(*args, **kwargs)
-        self.fields['auth'].queryset = Auth.objects.filter(secret_type='machine_reg')
+        self.fields["auth"].queryset = Auth.objects.filter(secret_type="machine_reg")
 
 
 class StorageAdminForm(forms.ModelForm):
     class Meta:
         model = Storage
-        fields = '__all__'
+        fields = "__all__"
 
     def __init__(self, *args, **kwargs):
         super(StorageAdminForm, self).__init__(*args, **kwargs)
-        self.fields['auth'].queryset = Auth.objects.filter(secret_type='storage_reg')
+        self.fields["auth"].queryset = Auth.objects.filter(secret_type="storage_reg")
 
 
 class AuthAdmin(CustomModelAdmin):
-    list_display = ('name', 'secret_type', 'date_added', 'active')
-    ordering = ('name',)
-    search_fields = ('name', 'comment',)
+    list_display = ("name", "secret_type", "date_added", "active")
+    ordering = ("name",)
+    search_fields = ("name", "comment")
 
 
 class ExcludeListFilter(admin.SimpleListFilter):
     def __init__(self, *args, **kwargs):
         if not self.title:
             self.title = self.parameter_name
-        self.parameter_name += '__exclude'
+        self.parameter_name += "__exclude"
         super(ExcludeListFilter, self).__init__(*args, **kwargs)
 
     def has_output(self):
@@ -125,7 +130,7 @@
 
 
 class NameExcludeListFilter(ExcludeListFilter):
-    parameter_name = 'name'
+    parameter_name = "name"
 
 
 class MachineAdmin(CustomModelAdmin):
@@ -133,61 +138,73 @@
         return get_admin_change_link(obj.storage)
 
     storage_link.allow_tags = True
-    storage_link.admin_order_field = 'storage__name'
-    storage_link.short_description = 'storage'
+    storage_link.admin_order_field = "storage__name"
+    storage_link.short_description = "storage"
 
     def date_checked_in_human(self, obj):
         return human_time(obj.date_checked_in)
 
-    date_checked_in_human.admin_order_field = 'date_checked_in'
-    date_checked_in_human.short_description = 'date checked in'
+    date_checked_in_human.admin_order_field = "date_checked_in"
+    date_checked_in_human.short_description = "date checked in"
 
     form = MachineAdminForm
     list_display = (
-        'unit_name', 'uuid', 'storage_link', 'environment_name',
-        'service_name', 'date_checked_in_human', 'published', 'active',
-        'healthy',
-    )
-    list_display_links = ('unit_name',)
-    list_filter = ('date_checked_in', 'storage', 'active', 'published')
-    ordering = ('unit_name',)
-    search_fields = (
-        'unit_name', 'uuid', 'environment_name', 'service_name',
-        'comment',
-    )
+        "unit_name",
+        "uuid",
+        "storage_link",
+        "environment_name",
+        "service_name",
+        "date_checked_in_human",
+        "published",
+        "active",
+        "healthy",
+    )
+    list_display_links = ("unit_name",)
+    list_filter = ("date_checked_in", "storage", "active", "published")
+    ordering = ("unit_name",)
+    search_fields = ("unit_name", "uuid", "environment_name", "service_name", "comment")
 
 
 class SourceAdmin(CustomModelAdmin):
     def date_last_backed_up_human(self, obj):
         return human_time(obj.date_last_backed_up)
 
-    date_last_backed_up_human.admin_order_field = 'date_last_backed_up'
-    date_last_backed_up_human.short_description = 'date last backed up'
+    date_last_backed_up_human.admin_order_field = "date_last_backed_up"
+    date_last_backed_up_human.short_description = "date last backed up"
 
     def date_next_backup_human(self, obj):
         return human_time(obj.date_next_backup)
 
-    date_next_backup_human.admin_order_field = 'date_next_backup'
-    date_next_backup_human.short_description = 'date next backup'
+    date_next_backup_human.admin_order_field = "date_next_backup"
+    date_next_backup_human.short_description = "date next backup"
 
     def machine_link(self, obj):
         return get_admin_change_link(obj.machine)
 
     machine_link.allow_tags = True
-    machine_link.admin_order_field = 'machine__unit_name'
-    machine_link.short_description = 'machine'
+    machine_link.admin_order_field = "machine__unit_name"
+    machine_link.short_description = "machine"
 
     list_display = (
-        'name', 'machine_link', 'path', 'date_last_backed_up_human',
-        'date_next_backup_human', 'published', 'active', 'healthy',
+        "name",
+        "machine_link",
+        "path",
+        "date_last_backed_up_human",
+        "date_next_backup_human",
+        "published",
+        "active",
+        "healthy",
     )
-    list_display_links = ('name',)
+    list_display_links = ("name",)
     list_filter = (
-        'date_last_backed_up', 'date_next_backup', 'active', 'published',
+        "date_last_backed_up",
+        "date_next_backup",
+        "active",
+        "published",
         NameExcludeListFilter,
     )
-    ordering = ('machine__unit_name', 'name')
-    search_fields = ('name', 'comment', 'path',)
+    ordering = ("machine__unit_name", "name")
+    search_fields = ("name", "comment", "path")
 
 
 class BackupLogAdmin(CustomModelAdmin):
@@ -195,8 +212,8 @@
         return get_admin_change_link(obj.source)
 
     source_link.allow_tags = True
-    source_link.admin_order_field = 'source__name'
-    source_link.short_description = 'source'
+    source_link.admin_order_field = "source__name"
+    source_link.short_description = "source"
 
     def duration(self, obj):
         if not (obj.date_end and obj.date_begin):
@@ -204,8 +221,8 @@
         d = obj.date_end - obj.date_begin
         return d - datetime.timedelta(microseconds=d.microseconds)
 
-    duration.admin_order_field = 'date_end'
-    duration.short_description = 'duration'
+    duration.admin_order_field = "date_end"
+    duration.short_description = "duration"
 
     def storage_link(self, obj):
         if not obj.storage:
@@ -213,57 +230,67 @@
         return get_admin_change_link(obj.storage)
 
     storage_link.allow_tags = True
-    storage_link.admin_order_field = 'storage__name'
-    storage_link.short_description = 'storage'
+    storage_link.admin_order_field = "storage__name"
+    storage_link.short_description = "storage"
 
     def date_human(self, obj):
         return human_time(obj.date)
 
-    date_human.admin_order_field = 'date'
-    date_human.short_description = 'date'
+    date_human.admin_order_field = "date"
+    date_human.short_description = "date"
 
     list_display = (
-        'date_human', 'source_link', 'success', 'snapshot', 'storage_link',
-        'duration',
+        "date_human",
+        "source_link",
+        "success",
+        "snapshot",
+        "storage_link",
+        "duration",
     )
-    list_display_links = ('date_human',)
-    list_filter = ('date', 'success')
-    ordering = ('-date',)
+    list_display_links = ("date_human",)
+    list_filter = ("date", "success")
+    ordering = ("-date",)
 
 
 class FilterSetAdmin(CustomModelAdmin):
-    list_display = ('name', 'date_added', 'active')
-    ordering = ('name',)
-    search_fields = ('name', 'comment',)
+    list_display = ("name", "date_added", "active")
+    ordering = ("name",)
+    search_fields = ("name", "comment")
 
 
 class StorageAdmin(CustomModelAdmin):
     def space_total_human(self, obj):
         return human_si(obj.space_total, 2)
 
-    space_total_human.admin_order_field = 'space_total'
-    space_total_human.short_description = 'space total'
+    space_total_human.admin_order_field = "space_total"
+    space_total_human.short_description = "space total"
 
     def space_available_human(self, obj):
         return human_si(obj.space_available, 2)
 
-    space_available_human.admin_order_field = 'space_available'
-    space_available_human.short_description = 'space available'
+    space_available_human.admin_order_field = "space_available"
+    space_available_human.short_description = "space available"
 
     def date_checked_in_human(self, obj):
         return human_time(obj.date_checked_in)
 
-    date_checked_in_human.admin_order_field = 'date_checked_in'
-    date_checked_in_human.short_description = 'date checked in'
+    date_checked_in_human.admin_order_field = "date_checked_in"
+    date_checked_in_human.short_description = "date checked in"
 
     form = StorageAdminForm
     list_display = (
-        'name', 'ssh_ping_host', 'ssh_ping_user', 'date_checked_in_human',
-        'space_total_human', 'space_available_human', 'published', 'active',
-        'healthy',
+        "name",
+        "ssh_ping_host",
+        "ssh_ping_user",
+        "date_checked_in_human",
+        "space_total_human",
+        "space_available_human",
+        "published",
+        "active",
+        "healthy",
     )
-    ordering = ('name',)
-    search_fields = ('name', 'comment', 'ssh_ping_host',)
+    ordering = ("name",)
+    search_fields = ("name", "comment", "ssh_ping_host")
 
 
 admin.site.register(Auth, AuthAdmin)
 
=== modified file 'turku_api/models.py'
--- turku_api/models.py	2020-04-11 21:20:31 +0000
+++ turku_api/models.py	2020-06-21 23:58:30 +0000
@@ -14,14 +14,15 @@
 # License along with this program.  If not, see
 # <http://www.gnu.org/licenses/>.
 
+from datetime import timedelta
+import json
+import uuid
+
 from django.db import models
+from django.contrib.auth.hashers import is_password_usable
 from django.core.exceptions import ValidationError
 from django.core.validators import MaxValueValidator, MinValueValidator
-from django.contrib.auth.hashers import is_password_usable
 from django.utils import timezone
-from datetime import timedelta
-import json
-import uuid
 
 
 def new_uuid():
@@ -32,85 +33,83 @@
     try:
         str(uuid.UUID(value))
     except ValueError:
-        raise ValidationError('Invalid UUID format')
+        raise ValidationError("Invalid UUID format")
 
 
 def validate_hashed_password(value):
     if not is_password_usable(value):
-        raise ValidationError('Invalid hashed password')
+        raise ValidationError("Invalid hashed password")
 
 
 def validate_json_string_list(value):
     try:
         decoded_json = json.loads(value)
     except ValueError:
-        raise ValidationError('Must be a valid JSON string list')
+        raise ValidationError("Must be a valid JSON string list")
     if not isinstance(decoded_json, (list, tuple, set)):
-        raise ValidationError('Must be a valid JSON string list')
+        raise ValidationError("Must be a valid JSON string list")
     for i in decoded_json:
         if not isinstance(i, str):
-            raise ValidationError('Must be a valid JSON string list')
+            raise ValidationError("Must be a valid JSON string list")
 
 
 def validate_storage_auth(value):
     try:
         a = Auth.objects.get(id=value)
     except Auth.DoesNotExist:
-        raise ValidationError('Auth %s does not exist' % value)
-    if a.secret_type != 'storage_reg':
-        raise ValidationError('Must be a Storage registration')
+        raise ValidationError("Auth %s does not exist" % value)
+    if a.secret_type != "storage_reg":
+        raise ValidationError("Must be a Storage registration")
 
 
 def validate_machine_auth(value):
     try:
         a = Auth.objects.get(id=value)
     except Auth.DoesNotExist:
-        raise ValidationError('Auth %s does not exist' % value)
-    if a.secret_type != 'machine_reg':
-        raise ValidationError('Must be a Machine registration')
+        raise ValidationError("Auth %s does not exist" % value)
+    if a.secret_type != "machine_reg":
+        raise ValidationError("Must be a Machine registration")
 
 
 class UuidPrimaryKeyField(models.CharField):
     def __init__(self, *args, **kwargs):
-        kwargs['blank'] = True
-        kwargs['default'] = new_uuid
-        kwargs['editable'] = False
-        kwargs['max_length'] = 36
-        kwargs['primary_key'] = True
+        kwargs["blank"] = True
+        kwargs["default"] = new_uuid
+        kwargs["editable"] = False
+        kwargs["max_length"] = 36
+        kwargs["primary_key"] = True
         super(UuidPrimaryKeyField, self).__init__(*args, **kwargs)
 
 
 class Auth(models.Model):
     SECRET_TYPES = (
-        ('machine_reg', 'Machine registration'),
-        ('storage_reg', 'Storage registration'),
+        ("machine_reg", "Machine registration"),
+        ("storage_reg", "Storage registration"),
     )
     id = UuidPrimaryKeyField()
     name = models.CharField(
-        max_length=200, unique=True,
-        help_text='Human-readable name of this auth.',
+        max_length=200, unique=True, help_text="Human-readable name of this auth."
     )
     secret_hash = models.CharField(
         max_length=200,
         validators=[validate_hashed_password],
-        help_text='Hashed secret (password) of this auth.',
+        help_text="Hashed secret (password) of this auth.",
     )
     secret_type = models.CharField(
-        max_length=200, choices=SECRET_TYPES,
-        help_text='Auth secret type (machine/storage).',
+        max_length=200,
+        choices=SECRET_TYPES,
+        help_text="Auth secret type (machine/storage).",
     )
     comment = models.CharField(
-        max_length=200, blank=True, null=True,
-        help_text='Human-readable comment.',
+        max_length=200, blank=True, null=True, help_text="Human-readable comment."
     )
     active = models.BooleanField(
         default=True,
-        help_text='Whether this auth is enabled.  Disabling prevents new registrations using its key, and prevents ' +
-                  'existing machines using its key from updating their configs.',
+        help_text="Whether this auth is enabled.  Disabling prevents new registrations using its key, and prevents "
+        + "existing machines using its key from updating their configs.",
     )
     date_added = models.DateTimeField(
-        default=timezone.now,
-        help_text='Date/time this auth was added.',
+        default=timezone.now, help_text="Date/time this auth was added."
     )
 
     def __str__(self):
@@ -125,77 +124,78 @@
             return True
         if not self.date_checked_in:
             return False
-        return (now <= (self.date_checked_in + timedelta(minutes=30)))
+        return now <= (self.date_checked_in + timedelta(minutes=30))
+
     healthy.boolean = True
 
     id = UuidPrimaryKeyField()
     name = models.CharField(
-        max_length=200, unique=True,
-        help_text='Name of this storage unit.  This is used as its login ID and must be unique.',
+        max_length=200,
+        unique=True,
+        help_text="Name of this storage unit.  This is used as its login ID and must be unique.",
     )
     secret_hash = models.CharField(
         max_length=200,
         validators=[validate_hashed_password],
-        help_text='Hashed secret (password) of this storage unit.',
+        help_text="Hashed secret (password) of this storage unit.",
     )
     comment = models.CharField(
-        max_length=200, blank=True, null=True,
-        help_text='Human-readable comment.',
+        max_length=200, blank=True, null=True, help_text="Human-readable comment."
     )
     ssh_ping_host = models.CharField(
         max_length=200,
-        verbose_name='SSH ping host',
-        help_text='Hostname/IP address of this storage unit\'s SSH server.',
+        verbose_name="SSH ping host",
+        help_text="Hostname/IP address of this storage unit's SSH server.",
     )
     ssh_ping_host_keys = models.CharField(
-        max_length=65536, default='[]',
+        max_length=65536,
+        default="[]",
         validators=[validate_json_string_list],
-        verbose_name='SSH ping host keys',
-        help_text='JSON list of this storage unit\'s SSH host keys.',
+        verbose_name="SSH ping host keys",
+        help_text="JSON list of this storage unit's SSH host keys.",
     )
     ssh_ping_port = models.PositiveIntegerField(
         validators=[MinValueValidator(1), MaxValueValidator(65535)],
-        verbose_name='SSH ping port',
-        help_text='Port number of this storage unit\'s SSH server.',
+        verbose_name="SSH ping port",
+        help_text="Port number of this storage unit's SSH server.",
     )
     ssh_ping_user = models.CharField(
         max_length=200,
-        verbose_name='SSH ping user',
-        help_text='Username of this storage unit\'s SSH server.',
+        verbose_name="SSH ping user",
+        help_text="Username of this storage unit's SSH server.",
     )
     space_total = models.PositiveIntegerField(
         default=0,
-        help_text='Total disk space of this storage unit\'s storage directories, in MiB.',
+        help_text="Total disk space of this storage unit's storage directories, in MiB.",
     )
     space_available = models.PositiveIntegerField(
         default=0,
-        help_text='Available disk space of this storage unit\'s storage directories, in MiB.',
+        help_text="Available disk space of this storage unit's storage directories, in MiB.",
     )
     auth = models.ForeignKey(
-        Auth, validators=[validate_storage_auth], on_delete=models.CASCADE,
-        help_text='Storage auth used to register this storage unit.',
+        Auth,
+        validators=[validate_storage_auth],
+        on_delete=models.CASCADE,
+        help_text="Storage auth used to register this storage unit.",
     )
     active = models.BooleanField(
         default=True,
-        help_text='Whether this storage unit is enabled.  Disabling prevents this storage unit from checking in or ' +
-                  'being assigned to new machines. Existing machines which ping this storage unit will get errors ' +
-                  'because this storage unit can no longer query the API server.',
+        help_text="Whether this storage unit is enabled.  Disabling prevents this storage unit from checking in or "
+        + "being assigned to new machines. Existing machines which ping this storage unit will get errors "
+        + "because this storage unit can no longer query the API server.",
     )
     published = models.BooleanField(
-        default=True,
-        help_text='Whether this storage unit has been enabled by itself.',
+        default=True, help_text="Whether this storage unit has been enabled by itself."
     )
     date_registered = models.DateTimeField(
-        default=timezone.now,
-        help_text='Date/time this storage unit was registered.',
+        default=timezone.now, help_text="Date/time this storage unit was registered."
     )
     date_updated = models.DateTimeField(
         default=timezone.now,
-        help_text='Date/time this storage unit presented a modified config.',
+        help_text="Date/time this storage unit presented a modified config.",
     )
     date_checked_in = models.DateTimeField(
-        blank=True, null=True,
-        help_text='Date/time this storage unit last checked in.',
+        blank=True, null=True, help_text="Date/time this storage unit last checked in."
     )
 
     def __str__(self):
@@ -210,75 +210,82 @@
             return True
         if not self.date_checked_in:
             return False
-        return (now <= (self.date_checked_in + timedelta(hours=10)))
+        return now <= (self.date_checked_in + timedelta(hours=10))
+
     healthy.boolean = True
 
     id = UuidPrimaryKeyField()
     uuid = models.CharField(
-        max_length=36, unique=True, validators=[validate_uuid],
-        verbose_name='UUID',
-        help_text='UUID of this machine.  This UUID is set by the machine and must be globally unique.',
+        max_length=36,
+        unique=True,
+        validators=[validate_uuid],
+        verbose_name="UUID",
+        help_text="UUID of this machine.  This UUID is set by the machine and must be globally unique.",
     )
     secret_hash = models.CharField(
         max_length=200,
         validators=[validate_hashed_password],
-        help_text='Hashed secret (password) of this machine.',
+        help_text="Hashed secret (password) of this machine.",
     )
     environment_name = models.CharField(
-        max_length=200, blank=True, null=True,
-        help_text='Environment this machine is part of.',
+        max_length=200,
+        blank=True,
+        null=True,
+        help_text="Environment this machine is part of.",
     )
     service_name = models.CharField(
-        max_length=200, blank=True, null=True,
-        help_text='Service this machine is part of.  For Juju units, this is the first part of the unit name ' +
-                  '(before the slash).',
+        max_length=200,
+        blank=True,
+        null=True,
+        help_text="Service this machine is part of.  For Juju units, this is the first part of the unit name "
+        + "(before the slash).",
     )
     unit_name = models.CharField(
         max_length=200,
-        help_text='Unit name of this machine.  For Juju units, this is the full unit name (e.g. "service-name/0").  ' +
-                  'Otherwise, this should be the machine\'s hostname.',
+        help_text='Unit name of this machine.  For Juju units, this is the full unit name (e.g. "service-name/0").  '
+        + "Otherwise, this should be the machine's hostname.",
     )
     comment = models.CharField(
-        max_length=200, blank=True, null=True,
-        help_text='Human-readable comment.',
+        max_length=200, blank=True, null=True, help_text="Human-readable comment."
     )
     ssh_public_key = models.CharField(
         max_length=2048,
-        verbose_name='SSH public key',
-        help_text='SSH public key of this machine\'s agent.',
+        verbose_name="SSH public key",
+        help_text="SSH public key of this machine's agent.",
     )
     auth = models.ForeignKey(
-        Auth, validators=[validate_machine_auth], on_delete=models.CASCADE,
-        help_text='Machine auth used to register this machine.',
+        Auth,
+        validators=[validate_machine_auth],
+        on_delete=models.CASCADE,
+        help_text="Machine auth used to register this machine.",
     )
     storage = models.ForeignKey(
-        Storage, on_delete=models.CASCADE,
-        help_text='Storage unit this machine is assigned to.',
+        Storage,
+        on_delete=models.CASCADE,
+        help_text="Storage unit this machine is assigned to.",
     )
     active = models.BooleanField(
         default=True,
-        help_text='Whether this machine is enabled.  Disabling removes its key from its storage unit, stops this ' +
-                  'machine from updating its registration, etc.',
+        help_text="Whether this machine is enabled.  Disabling removes its key from its storage unit, stops this "
+        + "machine from updating its registration, etc.",
     )
     published = models.BooleanField(
         default=True,
-        help_text='Whether this machine has been enabled by the machine agent.',
+        help_text="Whether this machine has been enabled by the machine agent.",
     )
     date_registered = models.DateTimeField(
-        default=timezone.now,
-        help_text='Date/time this machine was registered.',
+        default=timezone.now, help_text="Date/time this machine was registered."
     )
     date_updated = models.DateTimeField(
         default=timezone.now,
-        help_text='Date/time this machine presented a modified config.',
+        help_text="Date/time this machine presented a modified config.",
     )
     date_checked_in = models.DateTimeField(
-        blank=True, null=True,
-        help_text='Date/time this machine last checked in.',
+        blank=True, null=True, help_text="Date/time this machine last checked in."
     )
 
     def __str__(self):
-        return '%s (%s)' % (self.unit_name, self.uuid[0:8])
+        return "%s (%s)" % (self.unit_name, self.uuid[0:8])
 
 
 class Source(models.Model):
@@ -289,174 +296,172 @@
             return True
         if not self.success:
             return False
-        return (now <= (self.date_next_backup + timedelta(hours=10)))
+        return now <= (self.date_next_backup + timedelta(hours=10))
+
     healthy.boolean = True
 
     SNAPSHOT_MODES = (
-        ('none', 'No snapshotting'),
-        ('attic', 'Attic'),
-        ('link-dest', 'Hardlink trees (rsync --link-dest)'),
+        ("none", "No snapshotting"),
+        ("attic", "Attic"),
+        ("link-dest", "Hardlink trees (rsync --link-dest)"),
     )
     id = UuidPrimaryKeyField()
     name = models.CharField(
-        max_length=200,
-        help_text='Computer-readable source name identifier.',
+        max_length=200, help_text="Computer-readable source name identifier."
     )
     machine = models.ForeignKey(
-        Machine, on_delete=models.CASCADE,
-        help_text='Machine this source belongs to.',
+        Machine, on_delete=models.CASCADE, help_text="Machine this source belongs to."
     )
     comment = models.CharField(
-        max_length=200, blank=True, null=True,
-        help_text='Human-readable comment.',
+        max_length=200, blank=True, null=True, help_text="Human-readable comment."
     )
     path = models.CharField(
-        max_length=200,
-        help_text='Full filesystem path of this source.',
+        max_length=200, help_text="Full filesystem path of this source."
     )
     filter = models.CharField(
-        max_length=2048, default='[]', validators=[validate_json_string_list],
-        help_text='JSON list of rsync-compatible --filter options.',
+        max_length=2048,
+        default="[]",
+        validators=[validate_json_string_list],
+        help_text="JSON list of rsync-compatible --filter options.",
     )
     exclude = models.CharField(
-        max_length=2048, default='[]', validators=[validate_json_string_list],
-        help_text='JSON list of rsync-compatible --exclude options.',
+        max_length=2048,
+        default="[]",
+        validators=[validate_json_string_list],
+        help_text="JSON list of rsync-compatible --exclude options.",
     )
     frequency = models.CharField(
-        max_length=200, default='daily',
-        help_text='How often to back up this source.',
+        max_length=200, default="daily", help_text="How often to back up this source."
     )
     retention = models.CharField(
-        max_length=200, default='last 5 days, earliest of month',
-        help_text='Retention schedule, describing when to preserve snapshots.',
+        max_length=200,
+        default="last 5 days, earliest of month",
+        help_text="Retention schedule, describing when to preserve snapshots.",
     )
     bwlimit = models.CharField(
         max_length=200,
-        blank=True, null=True,
-        verbose_name='bandwidth limit',
-        help_text='Bandwith limit for remote transfer, using the rsync --bwlimit format.',
+        blank=True,
+        null=True,
+        verbose_name="bandwidth limit",
+        help_text="Bandwith limit for remote transfer, using the rsync --bwlimit format.",
     )
     snapshot_mode = models.CharField(
-        blank=True, null=True,
-        max_length=200, choices=SNAPSHOT_MODES,
-        help_text='Override the storage unit\'s snapshot logic and use an explicit snapshot mode for this source.',
+        blank=True,
+        null=True,
+        max_length=200,
+        choices=SNAPSHOT_MODES,
+        help_text="Override the storage unit's snapshot logic and use an explicit snapshot mode for this source.",
     )
     preserve_hard_links = models.BooleanField(
         default=False,
-        help_text='Whether to preserve hard links when backing up this source.',
+        help_text="Whether to preserve hard links when backing up this source.",
     )
     shared_service = models.BooleanField(
         default=False,
-        help_text='Whether this source is part of a shared service of multiple machines to be backed up.',
+        help_text="Whether this source is part of a shared service of multiple machines to be backed up.",
     )
     large_rotating_files = models.BooleanField(
         default=False,
-        help_text='Whether this source contains a number of large files which rotate through filenames, e.g. ' +
-                  '"postgresql.1.dump.gz" becomes "postgresql.2.dump.gz".',
+        help_text="Whether this source contains a number of large files which rotate through filenames, e.g. "
+        + '"postgresql.1.dump.gz" becomes "postgresql.2.dump.gz".',
     )
     large_modifying_files = models.BooleanField(
         default=False,
-        help_text='Whether this source contains a number of large files which grow or are otherwise modified, ' +
-                  'e.g. log files or filesystem images.',
+        help_text="Whether this source contains a number of large files which grow or are otherwise modified, "
+        + "e.g. log files or filesystem images.",
     )
     active = models.BooleanField(
         default=True,
-        help_text='Whether this source is enabled.  Disabling means the API server no longer gives it to the ' +
-                  'storage unit, even if it\'s time for a backup.',
+        help_text="Whether this source is enabled.  Disabling means the API server no longer gives it to the "
+        + "storage unit, even if it's time for a backup.",
     )
     success = models.BooleanField(
-        default=True,
-        help_text='Whether this source\'s last backup was successful.',
+        default=True, help_text="Whether this source's last backup was successful."
     )
     published = models.BooleanField(
         default=True,
-        help_text='Whether this source is actively being published by the machine agent.',
+        help_text="Whether this source is actively being published by the machine agent.",
     )
     date_added = models.DateTimeField(
         default=timezone.now,
-        help_text='Date/time this source was first added by the machine agent.',
+        help_text="Date/time this source was first added by the machine agent.",
     )
     date_updated = models.DateTimeField(
         default=timezone.now,
-        help_text='Date/time the machine presented a modified config of this source.',
+        help_text="Date/time the machine presented a modified config of this source.",
     )
     date_last_backed_up = models.DateTimeField(
-        blank=True, null=True,
-        help_text='Date/time this source was last successfully backed up.',
+        blank=True,
+        null=True,
+        help_text="Date/time this source was last successfully backed up.",
     )
     date_next_backup = models.DateTimeField(
         default=timezone.now,
-        help_text='Date/time this source is next scheduled to be backed up.  Set to now (or in the past) to ' +
-                  'trigger a backup as soon as possible.',
+        help_text="Date/time this source is next scheduled to be backed up.  Set to now (or in the past) to "
+        + "trigger a backup as soon as possible.",
     )
 
     class Meta:
-        unique_together = (('machine', 'name'),)
+        unique_together = (("machine", "name"),)
 
     def __str__(self):
-        return '%s %s' % (self.machine.unit_name, self.name)
+        return "%s %s" % (self.machine.unit_name, self.name)
 
 
 class BackupLog(models.Model):
     id = UuidPrimaryKeyField()
     source = models.ForeignKey(
-        Source, on_delete=models.CASCADE,
-        help_text='Source this log entry belongs to.',
+        Source, on_delete=models.CASCADE, help_text="Source this log entry belongs to."
     )
     date = models.DateTimeField(
         default=timezone.now,
-        help_text='Date/time this log entry was received/processed.',
+        help_text="Date/time this log entry was received/processed.",
     )
     storage = models.ForeignKey(
-        Storage, blank=True, null=True, on_delete=models.CASCADE,
-        help_text='Storage unit this backup occurred on.',
+        Storage,
+        blank=True,
+        null=True,
+        on_delete=models.CASCADE,
+        help_text="Storage unit this backup occurred on.",
     )
     success = models.BooleanField(
-        default=False,
-        help_text='Whether this backup succeeded.',
+        default=False, help_text="Whether this backup succeeded."
     )
     date_begin = models.DateTimeField(
-        blank=True, null=True,
-        help_text='Date/time this backup began.',
+        blank=True, null=True, help_text="Date/time this backup began."
     )
     date_end = models.DateTimeField(
-        blank=True, null=True,
-        help_text='Date/time this backup ended.',
+        blank=True, null=True, help_text="Date/time this backup ended."
     )
     snapshot = models.CharField(
-        max_length=200, blank=True, null=True,
-        help_text='Name of the created snapshot.',
+        max_length=200, blank=True, null=True, help_text="Name of the created snapshot."
     )
     summary = models.TextField(
-        blank=True, null=True,
-        help_text='Summary of the backup\'s events.',
+        blank=True, null=True, help_text="Summary of the backup's events."
     )
 
     def __str__(self):
-        return '%s %s' % (str(self.source), self.date.strftime('%Y-%m-%d %H:%M:%S'))
+        return "%s %s" % (str(self.source), self.date.strftime("%Y-%m-%d %H:%M:%S"))
 
 
 class FilterSet(models.Model):
     id = UuidPrimaryKeyField()
     name = models.CharField(
-        max_length=200, unique=True,
-        help_text='Name of this filter set.',
+        max_length=200, unique=True, help_text="Name of this filter set."
     )
     filters = models.TextField(
-        default='[]', validators=[validate_json_string_list],
-        help_text='JSON list of this filter set\'s filter rules.',
+        default="[]",
+        validators=[validate_json_string_list],
+        help_text="JSON list of this filter set's filter rules.",
     )
     comment = models.CharField(
-        max_length=200, blank=True, null=True,
-        help_text='Human-readable comment.',
+        max_length=200, blank=True, null=True, help_text="Human-readable comment."
     )
     active = models.BooleanField(
-        default=True,
-        help_text='Whether this filter set is enabled.',
+        default=True, help_text="Whether this filter set is enabled."
     )
     date_added = models.DateTimeField(
-        default=timezone.now,
-        help_text='Date/time this filter set was added.',
+        default=timezone.now, help_text="Date/time this filter set was added."
     )
 
     def __str__(self):
 
=== modified file 'turku_api/settings.py'
--- turku_api/settings.py	2020-04-11 21:20:31 +0000
+++ turku_api/settings.py	2020-06-21 23:58:30 +0000
@@ -21,57 +21,59 @@
 BASE_DIR = os.path.dirname(os.path.dirname(__file__))
 DEBUG = False
 TEMPLATE_DEBUG = False
-ALLOWED_HOSTS = ('*',)
+ALLOWED_HOSTS = ("*",)
 INSTALLED_APPS = (
-    'django.contrib.admin',
-    'django.contrib.auth',
-    'django.contrib.contenttypes',
-    'django.contrib.sessions',
-    'django.contrib.messages',
-    'django.contrib.staticfiles',
-    'turku_api',
+    "django.contrib.admin",
+    "django.contrib.auth",
+    "django.contrib.contenttypes",
+    "django.contrib.sessions",
+    "django.contrib.messages",
+    "django.contrib.staticfiles",
+    "turku_api",
 )
 MIDDLEWARE = (
-    'django.contrib.sessions.middleware.SessionMiddleware',
-    'django.middleware.common.CommonMiddleware',
-    'django.middleware.csrf.CsrfViewMiddleware',
-    'django.contrib.auth.middleware.AuthenticationMiddleware',
-    'django.contrib.messages.middleware.MessageMiddleware',
-    'django.middleware.clickjacking.XFrameOptionsMiddleware',
+    "django.contrib.sessions.middleware.SessionMiddleware",
+    "django.middleware.common.CommonMiddleware",
+    "django.middleware.csrf.CsrfViewMiddleware",
+    "django.contrib.auth.middleware.AuthenticationMiddleware",
+    "django.contrib.messages.middleware.MessageMiddleware",
+    "django.middleware.clickjacking.XFrameOptionsMiddleware",
 )
 MIDDLEWARE_CLASSES = MIDDLEWARE  # pre-1.10
-ROOT_URLCONF = 'turku_api.urls'
-WSGI_APPLICATION = 'turku_api.wsgi.application'
-LANGUAGE_CODE = 'en-us'
-TIME_ZONE = 'UTC'
+ROOT_URLCONF = "turku_api.urls"
+WSGI_APPLICATION = "turku_api.wsgi.application"
+LANGUAGE_CODE = "en-us"
+TIME_ZONE = "UTC"
 USE_I18N = True
 USE_L10N = True
 USE_TZ = True
-STATIC_URL = '/static/'
+STATIC_URL = "/static/"
 TEMPLATES = [
     {
-        'BACKEND': 'django.template.backends.django.DjangoTemplates',
-        'DIRS': [os.path.join(BASE_DIR, 'turku_api/templates')],
-        'APP_DIRS': True,
-        'OPTIONS': {
-            'context_processors': [
-                'django.template.context_processors.debug',
-                'django.template.context_processors.request',
-                'django.contrib.auth.context_processors.auth',
-                'django.contrib.messages.context_processors.messages',
-            ],
+        "BACKEND": "django.template.backends.django.DjangoTemplates",
+        "DIRS": [os.path.join(BASE_DIR, "turku_api/templates")],
+        "APP_DIRS": True,
+        "OPTIONS": {
+            "context_processors": [
+                "django.template.context_processors.debug",
+                "django.template.context_processors.request",
+                "django.contrib.auth.context_processors.auth",
+                "django.contrib.messages.context_processors.messages",
+            ]
         },
-    },
+    }
 ]
 DATABASES = {
-    'default': {
-        'ENGINE': 'django.db.backends.sqlite3',
-        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
+    "default": {
+        "ENGINE": "django.db.backends.sqlite3",
+        "NAME": os.path.join(BASE_DIR, "db.sqlite3"),
     }
 }
-SECRET_KEY = ''.join(random.choice(string.ascii_letters + string.digits) for i in range(30))
+SECRET_KEY = "".join(
+    random.choice(string.ascii_letters + string.digits) for i in range(30)
+)
 
 try:
-    from turku_api.local_settings import *
+    from turku_api.local_settings import *  # noqa: F401,F403
 except ImportError:
     pass
 
=== removed file 'turku_api/tests.py'
=== modified file 'turku_api/urls.py'
--- turku_api/urls.py	2020-04-11 21:20:31 +0000
+++ turku_api/urls.py	2020-06-21 23:58:30 +0000
@@ -14,31 +14,49 @@
 # License along with this program.  If not, see
 # <http://www.gnu.org/licenses/>.
 
-from django.conf.urls import include, url
+from django.conf.urls import url
+from django.contrib import admin
+from django.views.generic.base import RedirectView
+
 try:
     from django.urls import reverse_lazy  # 1.10+
 except ModuleNotFoundError:
     from django.core.urlresolvers import reverse_lazy  # pre-1.10
-from django.views.generic.base import RedirectView
+
 from turku_api import views
-from django.contrib import admin
 
 
 admin.autodiscover()
 
 urlpatterns = [
-    url(r'^$', RedirectView.as_view(url=reverse_lazy('admin:index'))),
-    url(r'^v1/health$', views.health, name='health'),
-    url(r'^v1/update_config$', views.update_config, name='update_config'),
-    url(r'^v1/agent_ping_checkin$', views.agent_ping_checkin, name='agent_ping_checkin'),
-    url(r'^v1/agent_ping_restore$', views.agent_ping_restore, name='agent_ping_restore'),
-    url(r'^v1/storage_ping_checkin$', views.storage_ping_checkin, name='storage_ping_checkin'),
-    url(r'^v1/storage_ping_source_update$', views.storage_ping_source_update, name='storage_ping_source_update'),
-    url(r'^v1/storage_update_config$', views.storage_update_config, name='storage_update_config'),
-    url(r'^admin/', admin.site.urls),
+    url(r"^$", RedirectView.as_view(url=reverse_lazy("admin:index"))),
+    url(r"^v1/health$", views.health, name="health"),
+    url(r"^v1/update_config$", views.update_config, name="update_config"),
+    url(
+        r"^v1/agent_ping_checkin$", views.agent_ping_checkin, name="agent_ping_checkin"
+    ),
+    url(
+        r"^v1/agent_ping_restore$", views.agent_ping_restore, name="agent_ping_restore"
+    ),
+    url(
+        r"^v1/storage_ping_checkin$",
+        views.storage_ping_checkin,
+        name="storage_ping_checkin",
+    ),
+    url(
+        r"^v1/storage_ping_source_update$",
+        views.storage_ping_source_update,
+        name="storage_ping_source_update",
+    ),
+    url(
+        r"^v1/storage_update_config$",
+        views.storage_update_config,
+        name="storage_update_config",
+    ),
+    url(r"^admin/", admin.site.urls),
 ]
 
 try:
-    from local_urls import *
+    from local_urls import *  # noqa: F401,F403
 except ImportError:
     pass
 
=== modified file 'turku_api/views.py'
--- turku_api/views.py	2020-03-24 23:07:22 +0000
+++ turku_api/views.py	2020-06-21 23:58:30 +0000
@@ -14,87 +14,107 @@
 # License along with this program.  If not, see
 # <http://www.gnu.org/licenses/>.
 
+from datetime import datetime, timedelta
+import json
+import random
+
+from django.contrib.auth import hashers
+from django.core.exceptions import ValidationError
 from django.http import (
-    HttpResponse, HttpResponseBadRequest, HttpResponseNotAllowed,
-    HttpResponseForbidden, HttpResponseNotFound,
+    HttpResponse,
+    HttpResponseBadRequest,
+    HttpResponseForbidden,
+    HttpResponseNotAllowed,
+    HttpResponseNotFound,
 )
+from django.utils import timezone
 from django.views.decorators.csrf import csrf_exempt
-from django.utils import timezone
-from django.core.exceptions import ValidationError
-
-from turku_api.models import Auth, Machine, Source, Storage, BackupLog, FilterSet
-
-import json
-import random
-from datetime import timedelta, datetime
-from django.contrib.auth import hashers
+
+from turku_api.models import Auth, BackupLog, FilterSet, Machine, Source, Storage
 
 
 def frequency_next_scheduled(frequency, base_time=None):
     if not base_time:
         base_time = timezone.now()
-    f = [x.strip() for x in frequency.split(',')]
+    f = [x.strip() for x in frequency.split(",")]
 
-    if f[0] == 'hourly':
-        target_time = (
-            base_time.replace(
-                minute=random.randint(0, 59), second=random.randint(0, 59), microsecond=0
-            ) + timedelta(hours=1)
-        )
+    if f[0] == "hourly":
+        target_time = base_time.replace(
+            minute=random.randint(0, 59), second=random.randint(0, 59), microsecond=0
+        ) + timedelta(hours=1)
         # Push it out 10 minutes if it falls within 10 minutes of now
         if target_time < (base_time + timedelta(minutes=10)):
-            target_time = (target_time + timedelta(minutes=10))
+            target_time = target_time + timedelta(minutes=10)
         return target_time
 
     today = base_time.replace(hour=0, minute=0, second=0, microsecond=0)
-    if f[0] == 'daily':
+    if f[0] == "daily":
         # Tomorrow
-        target_date = (today + timedelta(days=1))
-    elif f[0] == 'weekly':
+        target_date = today + timedelta(days=1)
+    elif f[0] == "weekly":
         # Random day next week
         target_day = random.randint(0, 6)
-        target_date = (today + timedelta(weeks=1) - timedelta(days=((today.weekday() + 1) % 7)) + timedelta(days=target_day))
+        target_date = (
+            today
+            + timedelta(weeks=1)
+            - timedelta(days=((today.weekday() + 1) % 7))
+            + timedelta(days=target_day)
+        )
         # Push it out 3 days if it falls within 3 days of now
         if target_date < (base_time + timedelta(days=3)):
-            target_date = (target_date + timedelta(days=3))
-    elif f[0] in ('sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday'):
+            target_date = target_date + timedelta(days=3)
+    elif f[0] in (
+        "sunday",
+        "monday",
+        "tuesday",
+        "wednesday",
+        "thursday",
+        "friday",
+        "saturday",
+    ):
         # Next Xday
         day_map = {
-            'sunday': 0,
-            'monday': 1,
-            'tuesday': 2,
-            'wednesday': 3,
-            'thursday': 4,
-            'friday': 5,
-            'saturday': 6,
+            "sunday": 0,
+            "monday": 1,
+            "tuesday": 2,
+            "wednesday": 3,
+            "thursday": 4,
+            "friday": 5,
+            "saturday": 6,
         }
         target_day = day_map[f[0]]
-        target_date = (today - timedelta(days=((today.weekday() + 1) % 7)) + timedelta(days=target_day))
+        target_date = (
+            today
+            - timedelta(days=((today.weekday() + 1) % 7))
+            + timedelta(days=target_day)
+        )
         if target_date < today:
-            target_date = (target_date + timedelta(weeks=1))
-    elif f[0] == 'monthly':
+            target_date = target_date + timedelta(weeks=1)
+    elif f[0] == "monthly":
         next_month = (today.replace(day=1) + timedelta(days=40)).replace(day=1)
         month_after = (next_month.replace(day=1) + timedelta(days=40)).replace(day=1)
-        target_date = (next_month + timedelta(days=random.randint(1, (month_after - next_month).days)))
+        target_date = next_month + timedelta(
+            days=random.randint(1, (month_after - next_month).days)
+        )
         # Push it out a week if it falls within a week of now
         if target_date < (base_time + timedelta(days=7)):
-            target_date = (target_date + timedelta(days=7))
+            target_date = target_date + timedelta(days=7)
     else:
         # Fall back to tomorrow
-        target_date = (today + timedelta(days=1))
+        target_date = today + timedelta(days=1)
 
     if len(f) == 1:
-        return (target_date + timedelta(seconds=random.randint(0, 86399)))
-    time_range = f[1].split('-')
+        return target_date + timedelta(seconds=random.randint(0, 86399))
+    time_range = f[1].split("-")
     start = (int(time_range[0][0:2]) * 60 * 60) + (int(time_range[0][2:4]) * 60)
     if len(time_range) == 1:
         # Not a range
-        return (target_date + timedelta(seconds=start))
+        return target_date + timedelta(seconds=start)
     end = (int(time_range[1][0:2]) * 60 * 60) + (int(time_range[1][2:4]) * 60)
     if end < start:
         # Day rollover
         end = end + 86400
-    return (target_date + timedelta(seconds=random.randint(start, end)))
+    return target_date + timedelta(seconds=random.randint(start, end))
 
 
 def random_weighted(m):
@@ -115,8 +135,9 @@
 
 def get_repo_revision():
     import os
+
     base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-    if os.path.isdir(os.path.join(base_dir, '.bzr')):
+    if os.path.isdir(os.path.join(base_dir, ".bzr")):
         try:
             import bzrlib.errors
             from bzrlib.branch import Branch
@@ -137,17 +158,22 @@
         return repr(self.message)
 
 
-class ViewV1():
+class ViewV1:
     def __init__(self, django_request):
         self.django_request = django_request
         self._parse_json_post()
 
     def _parse_json_post(self):
         # Require JSON POST
-        if not self.django_request.method == 'POST':
-            raise HttpResponseException(HttpResponseNotAllowed(['POST']))
-        if not (('CONTENT_TYPE' in self.django_request.META) and (self.django_request.META['CONTENT_TYPE'] == 'application/json')):
-            raise HttpResponseException(HttpResponseBadRequest('Bad Content-Type (expected application/json)'))
+        if not self.django_request.method == "POST":
+            raise HttpResponseException(HttpResponseNotAllowed(["POST"]))
+        if not (
+            ("CONTENT_TYPE" in self.django_request.META)
+            and (self.django_request.META["CONTENT_TYPE"] == "application/json")
+        ):
+            raise HttpResponseException(
+                HttpResponseBadRequest("Bad Content-Type (expected application/json)")
+            )
 
         # Load the POSTed JSON
         try:
@@ -157,80 +183,103 @@
 
     def _storage_authenticate(self):
         # Check for storage auth
-        if 'storage' not in self.req:
-            raise HttpResponseException(HttpResponseBadRequest('Missing required option "storage"'))
-        for k in ('name', 'secret'):
-            if k not in self.req['storage']:
-                raise HttpResponseException(HttpResponseForbidden('Bad auth'))
+        if "storage" not in self.req:
+            raise HttpResponseException(
+                HttpResponseBadRequest('Missing required option "storage"')
+            )
+        for k in ("name", "secret"):
+            if k not in self.req["storage"]:
+                raise HttpResponseException(HttpResponseForbidden("Bad auth"))
         try:
-            self.storage = Storage.objects.get(name=self.req['storage']['name'], active=True)
+            self.storage = Storage.objects.get(
+                name=self.req["storage"]["name"], active=True
+            )
         except Storage.DoesNotExist:
-            raise HttpResponseException(HttpResponseForbidden('Bad auth'))
-        if not hashers.check_password(self.req['storage']['secret'], self.storage.secret_hash):
-            raise HttpResponseException(HttpResponseForbidden('Bad auth'))
+            raise HttpResponseException(HttpResponseForbidden("Bad auth"))
+        if not hashers.check_password(
+            self.req["storage"]["secret"], self.storage.secret_hash
+        ):
+            raise HttpResponseException(HttpResponseForbidden("Bad auth"))
 
     def _storage_get_machine(self):
         # Make sure these exist in the request
-        if 'machine' not in self.req:
-            raise HttpResponseException(HttpResponseBadRequest('Missing required option "machine"'))
-        if 'uuid' not in self.req['machine']:
-            raise HttpResponseException(HttpResponseBadRequest('Missing required option "machine.uuid"'))
+        if "machine" not in self.req:
+            raise HttpResponseException(
+                HttpResponseBadRequest('Missing required option "machine"')
+            )
+        if "uuid" not in self.req["machine"]:
+            raise HttpResponseException(
+                HttpResponseBadRequest('Missing required option "machine.uuid"')
+            )
 
         # Create or load the machine
         try:
-            return Machine.objects.get(uuid=self.req['machine']['uuid'], storage=self.storage, active=True, published=True)
+            return Machine.objects.get(
+                uuid=self.req["machine"]["uuid"],
+                storage=self.storage,
+                active=True,
+                published=True,
+            )
         except Machine.DoesNotExist:
-            raise HttpResponseException(HttpResponseNotFound('Machine not found'))
+            raise HttpResponseException(HttpResponseNotFound("Machine not found"))
 
     def get_registration_auth(self, secret_type):
         # Check for global auth
-        if 'auth' not in self.req:
-            raise HttpResponseException(HttpResponseForbidden('Bad auth'))
-        if isinstance(self.req['auth'], dict):
-            if not (('name' in self.req['auth']) and ('secret' in self.req['auth'])):
-                raise HttpResponseException(HttpResponseForbidden('Bad auth'))
+        if "auth" not in self.req:
+            raise HttpResponseException(HttpResponseForbidden("Bad auth"))
+        if isinstance(self.req["auth"], dict):
+            if not (("name" in self.req["auth"]) and ("secret" in self.req["auth"])):
+                raise HttpResponseException(HttpResponseForbidden("Bad auth"))
             try:
-                a = Auth.objects.get(name=self.req['auth']['name'], secret_type=secret_type, active=True)
+                a = Auth.objects.get(
+                    name=self.req["auth"]["name"], secret_type=secret_type, active=True
+                )
             except Auth.DoesNotExist:
-                raise HttpResponseException(HttpResponseForbidden('Bad auth'))
-            if hashers.check_password(self.req['auth']['secret'], a.secret_hash):
+                raise HttpResponseException(HttpResponseForbidden("Bad auth"))
+            if hashers.check_password(self.req["auth"]["secret"], a.secret_hash):
                 return a
         else:
             # XXX inefficient but temporary (legacy)
             for a in Auth.objects.filter(secret_type=secret_type, active=True):
-                if hashers.check_password(self.req['auth'], a.secret_hash):
+                if hashers.check_password(self.req["auth"], a.secret_hash):
                     return a
-        raise HttpResponseException(HttpResponseForbidden('Bad auth'))
+        raise HttpResponseException(HttpResponseForbidden("Bad auth"))
 
     def update_config(self):
-        if not (('machine' in self.req) and (isinstance(self.req['machine'], dict))):
-            raise HttpResponseException(HttpResponseBadRequest('"machine" dict required'))
-        req_machine = self.req['machine']
+        if not (("machine" in self.req) and (isinstance(self.req["machine"], dict))):
+            raise HttpResponseException(
+                HttpResponseBadRequest('"machine" dict required')
+            )
+        req_machine = self.req["machine"]
 
         # Make sure these exist in the request (validation comes later)
-        for k in ('uuid', 'secret'):
+        for k in ("uuid", "secret"):
             if k not in req_machine:
-                raise HttpResponseException(HttpResponseBadRequest('Missing required machine option "%s"' % k))
+                raise HttpResponseException(
+                    HttpResponseBadRequest('Missing required machine option "%s"' % k)
+                )
 
         # Create or load the machine
         try:
-            m = Machine.objects.get(uuid=req_machine['uuid'], active=True)
+            m = Machine.objects.get(uuid=req_machine["uuid"], active=True)
             modified = False
         except Machine.DoesNotExist:
-            m = Machine(uuid=req_machine['uuid'])
-            m.secret_hash = hashers.make_password(req_machine['secret'])
-            m.auth = self.get_registration_auth('machine_reg')
+            m = Machine(uuid=req_machine["uuid"])
+            m.secret_hash = hashers.make_password(req_machine["secret"])
+            m.auth = self.get_registration_auth("machine_reg")
             modified = True
 
         # If the machine existed before, it had a secret.  Make sure that
         # hasn't changed.
-        if not hashers.check_password(req_machine['secret'], m.secret_hash):
-            raise HttpResponseException(HttpResponseForbidden('Bad secret for existing machine'))
+        if not hashers.check_password(req_machine["secret"], m.secret_hash):
+            raise HttpResponseException(
+                HttpResponseForbidden("Bad secret for existing machine")
+            )
 
         # Change the machine published status if needed
-        if ('published' in req_machine):
-            if req_machine['published'] != m.published:
-                m.published = req_machine['published']
+        if "published" in req_machine:
+            if req_machine["published"] != m.published:
+                m.published = req_machine["published"]
                 modified = True
         else:
             # If not present, default to want published
@@ -251,11 +300,19 @@
                 m.storage = random_weighted(weights)
                 modified = True
             except IndexError:
-                raise HttpResponseException(HttpResponseNotFound('No storages are currently available'))
+                raise HttpResponseException(
+                    HttpResponseNotFound("No storages are currently available")
+                )
 
         # If any of these exist in the request, add or update them in the
         # machine.
-        for k in ('environment_name', 'service_name', 'unit_name', 'comment', 'ssh_public_key'):
+        for k in (
+            "environment_name",
+            "service_name",
+            "unit_name",
+            "comment",
+            "ssh_public_key",
+        ):
             if (k in req_machine) and (getattr(m, k) != req_machine[k]):
                 setattr(m, k, req_machine[k])
                 modified = True
@@ -266,18 +323,24 @@
             try:
                 m.full_clean()
             except ValidationError as e:
-                raise HttpResponseException(HttpResponseBadRequest('Validation error: %s' % str(e)))
+                raise HttpResponseException(
+                    HttpResponseBadRequest("Validation error: %s" % str(e))
+                )
             m.save()
 
-        if 'sources' in req_machine:
-            req_sources = req_machine['sources']
+        if "sources" in req_machine:
+            req_sources = req_machine["sources"]
             if not isinstance(req_sources, dict):
-                raise HttpResponseException(HttpResponseBadRequest('Invalid type for "sources"'))
-        elif 'sources' in self.req:
+                raise HttpResponseException(
+                    HttpResponseBadRequest('Invalid type for "sources"')
+                )
+        elif "sources" in self.req:
             # XXX legacy
-            req_sources = self.req['sources']
+            req_sources = self.req["sources"]
             if not isinstance(req_sources, dict):
-                raise HttpResponseException(HttpResponseBadRequest('Invalid type for "sources"'))
+                raise HttpResponseException(
+                    HttpResponseBadRequest('Invalid type for "sources"')
+                )
         else:
             req_sources = {}
 
@@ -291,17 +354,27 @@
 
             modified = False
             for k in (
-                'path', 'frequency', 'retention',
-                'comment', 'shared_service', 'large_rotating_files',
-                'large_modifying_files', 'bwlimit', 'snapshot_mode',
-                'preserve_hard_links',
+                "path",
+                "frequency",
+                "retention",
+                "comment",
+                "shared_service",
+                "large_rotating_files",
+                "large_modifying_files",
+                "bwlimit",
+                "snapshot_mode",
+                "preserve_hard_links",
             ):
-                if (k in req_sources[s.name]) and (getattr(s, k) != req_sources[s.name][k]):
+                if (k in req_sources[s.name]) and (
+                    getattr(s, k) != req_sources[s.name][k]
+                ):
                     setattr(s, k, req_sources[s.name][k])
-                    if k == 'frequency':
-                        s.date_next_backup = frequency_next_scheduled(req_sources[s.name][k])
+                    if k == "frequency":
+                        s.date_next_backup = frequency_next_scheduled(
+                            req_sources[s.name][k]
+                        )
                     modified = True
-            for k in ('filter', 'exclude'):
+            for k in ("filter", "exclude"):
                 if k not in req_sources[s.name]:
                     continue
                 v = json.dumps(req_sources[s.name][k], sort_keys=True)
@@ -315,7 +388,9 @@
                 try:
                     s.full_clean()
                 except ValidationError as e:
-                    raise HttpResponseException(HttpResponseBadRequest('Validation error: %s' % str(e)))
+                    raise HttpResponseException(
+                        HttpResponseBadRequest("Validation error: %s" % str(e))
+                    )
                 s.save()
 
         for name in req_sources:
@@ -326,15 +401,21 @@
             s.machine = m
 
             for k in (
-                'path', 'frequency', 'retention',
-                'comment', 'shared_service', 'large_rotating_files',
-                'large_modifying_files', 'bwlimit', 'snapshot_mode',
-                'preserve_hard_links',
+                "path",
+                "frequency",
+                "retention",
+                "comment",
+                "shared_service",
+                "large_rotating_files",
+                "large_modifying_files",
+                "bwlimit",
+                "snapshot_mode",
+                "preserve_hard_links",
             ):
                 if k not in req_sources[s.name]:
                     continue
                 setattr(s, k, req_sources[s.name][k])
-            for k in ('filter', 'exclude'):
+            for k in ("filter", "exclude"):
                 if k not in req_sources[s.name]:
                     continue
                 v = json.dumps(req_sources[s.name][k], sort_keys=True)
@@ -346,18 +427,20 @@
             try:
                 s.full_clean()
             except ValidationError as e:
-                raise HttpResponseException(HttpResponseBadRequest('Validation error: %s' % str(e)))
+                raise HttpResponseException(
+                    HttpResponseBadRequest("Validation error: %s" % str(e))
+                )
             s.save()
 
         # XXX legacy
         out = {
-            'storage_name': m.storage.name,
-            'ssh_ping_host': m.storage.ssh_ping_host,
-            'ssh_ping_host_keys': json.loads(m.storage.ssh_ping_host_keys),
-            'ssh_ping_port': m.storage.ssh_ping_port,
-            'ssh_ping_user': m.storage.ssh_ping_user,
+            "storage_name": m.storage.name,
+            "ssh_ping_host": m.storage.ssh_ping_host,
+            "ssh_ping_host_keys": json.loads(m.storage.ssh_ping_host_keys),
+            "ssh_ping_port": m.storage.ssh_ping_port,
+            "ssh_ping_user": m.storage.ssh_ping_user,
         }
-        return HttpResponse(json.dumps(out), content_type='application/json')
+        return HttpResponse(json.dumps(out), content_type="application/json")
 
     def build_filters(self, set, loaded_sets=None):
         if not loaded_sets:
@@ -365,10 +448,10 @@
         out = []
         for f in set:
             try:
-                (verb, subsetname) = f.split(' ', 1)
+                (verb, subsetname) = f.split(" ", 1)
             except ValueError:
                 continue
-            if verb in ('merge', '.'):
+            if verb in ("merge", "."):
                 if subsetname in loaded_sets:
                     continue
                 try:
@@ -379,10 +462,22 @@
                     out.append(f2)
                 loaded_sets.append(subsetname)
             elif verb in (
-                'dir-merge', ':', 'clear', '!',
-                'exclude', '-', 'include', '+',
-                'hide', 'H', 'show', 'S',
-                'protect', 'P', 'risk', 'R',
+                "dir-merge",
+                ":",
+                "clear",
+                "!",
+                "exclude",
+                "-",
+                "include",
+                "+",
+                "hide",
+                "H",
+                "show",
+                "S",
+                "protect",
+                "P",
+                "risk",
+                "R",
             ):
                 out.append(f)
         return out
@@ -390,109 +485,117 @@
     def get_checkin_scheduled_sources(self, m):
         scheduled_sources = {}
         now = timezone.now()
-        for s in m.source_set.filter(date_next_backup__lte=now, active=True, published=True):
+        for s in m.source_set.filter(
+            date_next_backup__lte=now, active=True, published=True
+        ):
             scheduled_sources[s.name] = {
-                'path': s.path,
-                'retention': s.retention,
-                'bwlimit': s.bwlimit,
-                'filter': self.build_filters(json.loads(s.filter)),
-                'exclude': json.loads(s.exclude),
-                'shared_service': s.shared_service,
-                'large_rotating_files': s.large_rotating_files,
-                'large_modifying_files': s.large_modifying_files,
-                'snapshot_mode': s.snapshot_mode,
-                'preserve_hard_links': s.preserve_hard_links,
-                'storage': {
-                    'name': s.machine.storage.name,
-                    'ssh_ping_host': s.machine.storage.ssh_ping_host,
-                    'ssh_ping_host_keys': json.loads(s.machine.storage.ssh_ping_host_keys),
-                    'ssh_ping_port': s.machine.storage.ssh_ping_port,
-                    'ssh_ping_user': s.machine.storage.ssh_ping_user,
-                }
+                "path": s.path,
+                "retention": s.retention,
+                "bwlimit": s.bwlimit,
+                "filter": self.build_filters(json.loads(s.filter)),
+                "exclude": json.loads(s.exclude),
+                "shared_service": s.shared_service,
+                "large_rotating_files": s.large_rotating_files,
+                "large_modifying_files": s.large_modifying_files,
+                "snapshot_mode": s.snapshot_mode,
+                "preserve_hard_links": s.preserve_hard_links,
+                "storage": {
+                    "name": s.machine.storage.name,
+                    "ssh_ping_host": s.machine.storage.ssh_ping_host,
+                    "ssh_ping_host_keys": json.loads(
+                        s.machine.storage.ssh_ping_host_keys
+                    ),
+                    "ssh_ping_port": s.machine.storage.ssh_ping_port,
+                    "ssh_ping_user": s.machine.storage.ssh_ping_user,
+                },
             }
         return scheduled_sources
 
     def agent_ping_checkin(self):
-        if not (('machine' in self.req) and (isinstance(self.req['machine'], dict))):
-            raise HttpResponseException(HttpResponseBadRequest('"machine" dict required'))
-        req_machine = self.req['machine']
+        if not (("machine" in self.req) and (isinstance(self.req["machine"], dict))):
+            raise HttpResponseException(
+                HttpResponseBadRequest('"machine" dict required')
+            )
+        req_machine = self.req["machine"]
 
         # Make sure these exist in the request
-        for k in ('uuid', 'secret'):
+        for k in ("uuid", "secret"):
             if k not in req_machine:
-                raise HttpResponseException(HttpResponseBadRequest('Missing required machine option "%s"' % k))
+                raise HttpResponseException(
+                    HttpResponseBadRequest('Missing required machine option "%s"' % k)
+                )
 
         # Load the machine
         try:
-            m = Machine.objects.get(uuid=req_machine['uuid'], active=True, published=True)
+            m = Machine.objects.get(
+                uuid=req_machine["uuid"], active=True, published=True
+            )
         except Machine.DoesNotExist:
-            raise HttpResponseException(HttpResponseForbidden('Bad auth'))
-        if not hashers.check_password(req_machine['secret'], m.secret_hash):
-            raise HttpResponseException(HttpResponseForbidden('Bad auth'))
+            raise HttpResponseException(HttpResponseForbidden("Bad auth"))
+        if not hashers.check_password(req_machine["secret"], m.secret_hash):
+            raise HttpResponseException(HttpResponseForbidden("Bad auth"))
 
         scheduled_sources = self.get_checkin_scheduled_sources(m)
         now = timezone.now()
 
-        out = {
-            'machine': {
-                'scheduled_sources': scheduled_sources,
-            },
-        }
+        out = {"machine": {"scheduled_sources": scheduled_sources}}
 
         # XXX legacy
-        out['scheduled_sources'] = scheduled_sources
+        out["scheduled_sources"] = scheduled_sources
 
         m.date_checked_in = now
         m.save()
-        return HttpResponse(json.dumps(out), content_type='application/json')
+        return HttpResponse(json.dumps(out), content_type="application/json")
 
     def agent_ping_restore(self):
-        if not (('machine' in self.req) and (isinstance(self.req['machine'], dict))):
-            raise HttpResponseException(HttpResponseBadRequest('"machine" dict required'))
-        req_machine = self.req['machine']
+        if not (("machine" in self.req) and (isinstance(self.req["machine"], dict))):
+            raise HttpResponseException(
+                HttpResponseBadRequest('"machine" dict required')
+            )
+        req_machine = self.req["machine"]
 
         # Make sure these exist in the request
-        for k in ('uuid', 'secret'):
+        for k in ("uuid", "secret"):
             if k not in req_machine:
-                raise HttpResponseException(HttpResponseBadRequest('Missing required machine option "%s"' % k))
+                raise HttpResponseException(
+                    HttpResponseBadRequest('Missing required machine option "%s"' % k)
+                )
 
         # Load the machine
         try:
-            m = Machine.objects.get(uuid=req_machine['uuid'], active=True)
+            m = Machine.objects.get(uuid=req_machine["uuid"], active=True)
         except Machine.DoesNotExist:
-            raise HttpResponseException(HttpResponseForbidden('Bad auth'))
-        if not hashers.check_password(req_machine['secret'], m.secret_hash):
-            raise HttpResponseException(HttpResponseForbidden('Bad auth'))
+            raise HttpResponseException(HttpResponseForbidden("Bad auth"))
+        if not hashers.check_password(req_machine["secret"], m.secret_hash):
+            raise HttpResponseException(HttpResponseForbidden("Bad auth"))
 
         sources = {}
         for s in m.source_set.filter(active=True):
             sources[s.name] = {
-                'path': s.path,
-                'retention': s.retention,
-                'bwlimit': s.bwlimit,
-                'filter': self.build_filters(json.loads(s.filter)),
-                'exclude': json.loads(s.exclude),
-                'shared_service': s.shared_service,
-                'large_rotating_files': s.large_rotating_files,
-                'large_modifying_files': s.large_modifying_files,
-                'snapshot_mode': s.snapshot_mode,
-                'preserve_hard_links': s.preserve_hard_links,
-                'storage': {
-                    'name': s.machine.storage.name,
-                    'ssh_ping_host': s.machine.storage.ssh_ping_host,
-                    'ssh_ping_host_keys': json.loads(s.machine.storage.ssh_ping_host_keys),
-                    'ssh_ping_port': s.machine.storage.ssh_ping_port,
-                    'ssh_ping_user': s.machine.storage.ssh_ping_user,
-                }
+                "path": s.path,
+                "retention": s.retention,
+                "bwlimit": s.bwlimit,
+                "filter": self.build_filters(json.loads(s.filter)),
+                "exclude": json.loads(s.exclude),
+                "shared_service": s.shared_service,
+                "large_rotating_files": s.large_rotating_files,
+                "large_modifying_files": s.large_modifying_files,
+                "snapshot_mode": s.snapshot_mode,
+                "preserve_hard_links": s.preserve_hard_links,
+                "storage": {
+                    "name": s.machine.storage.name,
+                    "ssh_ping_host": s.machine.storage.ssh_ping_host,
+                    "ssh_ping_host_keys": json.loads(
+                        s.machine.storage.ssh_ping_host_keys
+                    ),
+                    "ssh_ping_port": s.machine.storage.ssh_ping_port,
+                    "ssh_ping_user": s.machine.storage.ssh_ping_user,
+                },
             }
 
-        out = {
-            'machine': {
-                'sources': sources,
-            },
-        }
+        out = {"machine": {"sources": sources}}
 
-        return HttpResponse(json.dumps(out), content_type='application/json')
+        return HttpResponse(json.dumps(out), content_type="application/json")
 
     def storage_ping_checkin(self):
         self._storage_authenticate()
@@ -502,32 +605,34 @@
         now = timezone.now()
 
         out = {
-            'machine': {
-                'uuid': m.uuid,
-                'environment_name': m.environment_name,
-                'service_name': m.service_name,
-                'unit_name': m.unit_name,
-                'scheduled_sources': scheduled_sources,
-            },
+            "machine": {
+                "uuid": m.uuid,
+                "environment_name": m.environment_name,
+                "service_name": m.service_name,
+                "unit_name": m.unit_name,
+                "scheduled_sources": scheduled_sources,
+            }
         }
         m.date_checked_in = now
         m.save()
-        return HttpResponse(json.dumps(out), content_type='application/json')
+        return HttpResponse(json.dumps(out), content_type="application/json")
 
     def storage_ping_source_update(self):
         self._storage_authenticate()
         m = self._storage_get_machine()
 
-        if 'sources' not in self.req['machine']:
-            raise HttpResponseException(HttpResponseBadRequest('Missing required option "machine.sources"'))
-        for source_name in self.req['machine']['sources']:
-            source_data = self.req['machine']['sources'][source_name]
+        if "sources" not in self.req["machine"]:
+            raise HttpResponseException(
+                HttpResponseBadRequest('Missing required option "machine.sources"')
+            )
+        for source_name in self.req["machine"]["sources"]:
+            source_data = self.req["machine"]["sources"][source_name]
             try:
                 s = m.source_set.get(name=source_name, active=True, published=True)
             except Source.DoesNotExist:
-                raise HttpResponseException(HttpResponseNotFound('Source not found'))
+                raise HttpResponseException(HttpResponseNotFound("Source not found"))
             now = timezone.now()
-            is_success = ('success' in source_data and source_data['success'])
+            is_success = "success" in source_data and source_data["success"]
             s.success = is_success
             if is_success:
                 s.date_last_backed_up = now
@@ -538,46 +643,63 @@
             bl.date = now
             bl.storage = self.storage
             bl.success = is_success
-            if 'snapshot' in source_data:
-                bl.snapshot = source_data['snapshot']
-            if 'summary' in source_data:
-                bl.summary = source_data['summary']
-            if 'time_begin' in source_data:
-                bl.date_begin = timezone.make_aware(datetime.utcfromtimestamp(source_data['time_begin']), timezone.utc)
-            if 'time_end' in source_data:
-                bl.date_end = timezone.make_aware(datetime.utcfromtimestamp(source_data['time_end']), timezone.utc)
+            if "snapshot" in source_data:
+                bl.snapshot = source_data["snapshot"]
+            if "summary" in source_data:
+                bl.summary = source_data["summary"]
+            if "time_begin" in source_data:
+                bl.date_begin = timezone.make_aware(
+                    datetime.utcfromtimestamp(source_data["time_begin"]), timezone.utc
+                )
+            if "time_end" in source_data:
+                bl.date_end = timezone.make_aware(
+                    datetime.utcfromtimestamp(source_data["time_end"]), timezone.utc
+                )
             bl.save()
-        return HttpResponse(json.dumps({}), content_type='application/json')
+        return HttpResponse(json.dumps({}), content_type="application/json")
 
     def storage_update_config(self):
-        if not (('storage' in self.req) and (isinstance(self.req['storage'], dict))):
-            raise HttpResponseException(HttpResponseBadRequest('"storage" dict required'))
-        req_storage = self.req['storage']
+        if not (("storage" in self.req) and (isinstance(self.req["storage"], dict))):
+            raise HttpResponseException(
+                HttpResponseBadRequest('"storage" dict required')
+            )
+        req_storage = self.req["storage"]
 
         # Make sure these exist in the request (validation comes later)
-        for k in ('name', 'secret', 'ssh_ping_host', 'ssh_ping_port', 'ssh_ping_user', 'ssh_ping_host_keys'):
+        for k in (
+            "name",
+            "secret",
+            "ssh_ping_host",
+            "ssh_ping_port",
+            "ssh_ping_user",
+            "ssh_ping_host_keys",
+        ):
             if k not in req_storage:
-                raise HttpResponseException(HttpResponseBadRequest('Missing required storage option "%s"' % k))
+                raise HttpResponseException(
+                    HttpResponseBadRequest('Missing required storage option "%s"' % k)
+                )
 
         # Create or load the storage
         try:
-            self.storage = Storage.objects.get(name=req_storage['name'], active=True)
+            self.storage = Storage.objects.get(name=req_storage["name"], active=True)
             modified = False
         except Storage.DoesNotExist:
-            self.storage = Storage(name=req_storage['name'])
-            self.storage.secret_hash = hashers.make_password(req_storage['secret'])
-            self.storage.auth = self.get_registration_auth('storage_reg')
+            self.storage = Storage(name=req_storage["name"])
+            self.storage.secret_hash = hashers.make_password(req_storage["secret"])
+            self.storage.auth = self.get_registration_auth("storage_reg")
             modified = True
 
         # If the storage existed before, it had a secret.  Make sure that
         # hasn't changed.
-        if not hashers.check_password(req_storage['secret'], self.storage.secret_hash):
-            raise HttpResponseException(HttpResponseForbidden('Bad secret for existing storage'))
+        if not hashers.check_password(req_storage["secret"], self.storage.secret_hash):
+            raise HttpResponseException(
+                HttpResponseForbidden("Bad secret for existing storage")
+            )
 
         # Change the storage published status if needed
-        if ('published' in req_storage):
-            if req_storage['published'] != self.storage.published:
-                self.storage.published = req_storage['published']
+        if "published" in req_storage:
+            if req_storage["published"] != self.storage.published:
+                self.storage.published = req_storage["published"]
                 modified = True
         else:
             # If not present, default to want published
@@ -587,12 +709,19 @@
 
         # If any of these exist in the request, add or update them in the
         # self.storage.
-        for k in ('comment', 'ssh_ping_host', 'ssh_ping_port', 'ssh_ping_user', 'space_total', 'space_available'):
+        for k in (
+            "comment",
+            "ssh_ping_host",
+            "ssh_ping_port",
+            "ssh_ping_user",
+            "space_total",
+            "space_available",
+        ):
             if (k in req_storage) and (getattr(self.storage, k) != req_storage[k]):
                 setattr(self.storage, k, req_storage[k])
                 modified = True
 
-        for k in ('ssh_ping_host_keys',):
+        for k in ("ssh_ping_host_keys",):
             if k not in req_storage:
                 continue
             v = json.dumps(req_storage[k], sort_keys=True)
@@ -606,21 +735,27 @@
             try:
                 self.storage.full_clean()
             except ValidationError as e:
-                raise HttpResponseException(HttpResponseBadRequest('Validation error: %s' % str(e)))
+                raise HttpResponseException(
+                    HttpResponseBadRequest("Validation error: %s" % str(e))
+                )
 
         self.storage.date_checked_in = timezone.now()
         self.storage.save()
 
         machines = {}
-        for m in Machine.objects.filter(storage=self.storage, active=True, published=True):
+        for m in Machine.objects.filter(
+            storage=self.storage, active=True, published=True
+        ):
             machines[m.uuid] = {
-                'environment_name': m.environment_name,
-                'service_name': m.service_name,
-                'unit_name': m.unit_name,
-                'comment': m.comment,
-                'ssh_public_key': m.ssh_public_key,
+                "environment_name": m.environment_name,
+                "service_name": m.service_name,
+                "unit_name": m.unit_name,
+                "comment": m.comment,
+                "ssh_public_key": m.ssh_public_key,
             }
-        return HttpResponse(json.dumps({'machines': machines}), content_type='application/json')
+        return HttpResponse(
+            json.dumps({"machines": machines}), content_type="application/json"
+        )
 
 
 @csrf_exempt
@@ -629,19 +764,19 @@
     # to connect to its database and serve data).  It does not
     # indicate the health of machines, storage units, etc.
     out = {
-        'healthy': True,
-        'date': timezone.now().isoformat(),
-        'repo_revision': get_repo_revision(),
-        'counts': {
-            'auth': Auth.objects.count(),
-            'storage': Storage.objects.count(),
-            'machine': Machine.objects.count(),
-            'source': Source.objects.count(),
-            'filter_set': FilterSet.objects.count(),
-            'backup_log': BackupLog.objects.count(),
+        "healthy": True,
+        "date": timezone.now().isoformat(),
+        "repo_revision": get_repo_revision(),
+        "counts": {
+            "auth": Auth.objects.count(),
+            "storage": Storage.objects.count(),
+            "machine": Machine.objects.count(),
+            "source": Source.objects.count(),
+            "filter_set": FilterSet.objects.count(),
+            "backup_log": BackupLog.objects.count(),
         },
     }
-    return HttpResponse(json.dumps(out), content_type='application/json')
+    return HttpResponse(json.dumps(out), content_type="application/json")
 
 
 @csrf_exempt
 
=== modified file 'turku_api/wsgi.py'
--- turku_api/wsgi.py	2015-07-30 22:41:42 +0000
+++ turku_api/wsgi.py	2020-06-21 23:58:30 +0000
@@ -25,9 +25,11 @@
 
 import os
 import sys
+
 BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 sys.path.append(BASE_DIR)
 os.environ.setdefault("DJANGO_SETTINGS_MODULE", "turku_api.settings")
 
-from django.core.wsgi import get_wsgi_application
+from django.core.wsgi import get_wsgi_application  # noqa: E402
+
 application = get_wsgi_application()