Format - black: ishtar_common

1 files changed, 1090 insertions, 928 deletions

diff --git a/ishtar_common/tests.py b/ishtar_common/tests.py
index 20f87b3bc..85d658160 100644
--- a/ishtar_common/tests.py
+++ b/ishtar_common/tests.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 # Copyright (C) 2015-2017 Étienne Loks  <etienne.loks_AT_peacefrogsDOTnet>
 
@@ -53,101 +53,109 @@ from django.test.runner import DiscoverRunner
 from ishtar_common import models, models_common
 from ishtar_common import views
 from ishtar_common.apps import admin_site
-from ishtar_common.serializers import type_serialization, \
-    SERIALIZATION_VERSION, \
-    restore_serialized, conf_serialization, CONF_MODEL_LIST, \
-    importer_serialization, IMPORT_MODEL_LIST, geo_serialization, \
-    GEO_MODEL_LIST, directory_serialization, DIRECTORY_MODEL_LIST, \
-    document_serialization, get_type_models, full_serialization
+from ishtar_common.serializers import (
+    type_serialization,
+    SERIALIZATION_VERSION,
+    restore_serialized,
+    conf_serialization,
+    CONF_MODEL_LIST,
+    importer_serialization,
+    IMPORT_MODEL_LIST,
+    geo_serialization,
+    GEO_MODEL_LIST,
+    directory_serialization,
+    DIRECTORY_MODEL_LIST,
+    document_serialization,
+    get_type_models,
+    full_serialization,
+)
 from archaeological_operations.serializers import OPERATION_MODEL_LIST
 from archaeological_context_records.serializers import CR_MODEL_LIST
 from archaeological_finds.serializers import FIND_MODEL_LIST
 from archaeological_warehouse.serializers import WAREHOUSE_MODEL_LIST
 from ishtar_common.serializers_utils import serialization_info
-from ishtar_common.utils import post_save_geo, update_data, move_dict_data, \
-    rename_and_simplify_media_name, try_fix_file
+from ishtar_common.utils import (
+    post_save_geo,
+    update_data,
+    move_dict_data,
+    rename_and_simplify_media_name,
+    try_fix_file,
+)
 from ishtar_common.tasks import launch_export
 from ishtar_common import utils_secretary
 
 
 COMMON_FIXTURES = [
-    settings.ROOT_PATH + '../fixtures/initial_data-auth-fr.json',
-    settings.ROOT_PATH + '../ishtar_common/fixtures/initial_data-fr.json',
-    settings.ROOT_PATH +
-    '../ishtar_common/fixtures/initial_spatialrefsystem-fr.json',
-    settings.ROOT_PATH +
-    '../ishtar_common/fixtures/initial_importtypes-fr.json',
-    ]
+    settings.ROOT_PATH + "../fixtures/initial_data-auth-fr.json",
+    settings.ROOT_PATH + "../ishtar_common/fixtures/initial_data-fr.json",
+    settings.ROOT_PATH + "../ishtar_common/fixtures/initial_spatialrefsystem-fr.json",
+    settings.ROOT_PATH + "../ishtar_common/fixtures/initial_importtypes-fr.json",
+]
 
 OPERATION_FIXTURES = COMMON_FIXTURES + [
-    settings.ROOT_PATH +
-    '../archaeological_operations/fixtures/initial_data-fr.json',
-    settings.ROOT_PATH +
-    '../archaeological_operations/fixtures/initial_data_relation_type_norel-fr.json',
-    settings.ROOT_PATH +
-    '../archaeological_operations/fixtures/initial_data_relation_type-fr.json',
+    settings.ROOT_PATH + "../archaeological_operations/fixtures/initial_data-fr.json",
+    settings.ROOT_PATH
+    + "../archaeological_operations/fixtures/initial_data_relation_type_norel-fr.json",
+    settings.ROOT_PATH
+    + "../archaeological_operations/fixtures/initial_data_relation_type-fr.json",
 ]
 
-OPERATION_TOWNS_FIXTURES = \
-    OPERATION_FIXTURES + \
-    [settings.ROOT_PATH + '../ishtar_common/fixtures/test_towns.json']
+OPERATION_TOWNS_FIXTURES = OPERATION_FIXTURES + [
+    settings.ROOT_PATH + "../ishtar_common/fixtures/test_towns.json"
+]
 
 FILE_FIXTURES = OPERATION_FIXTURES + [
-    settings.ROOT_PATH +
-    '../archaeological_files/fixtures/initial_data-fr.json']
+    settings.ROOT_PATH + "../archaeological_files/fixtures/initial_data-fr.json"
+]
 
 FILE_TOWNS_FIXTURES = OPERATION_TOWNS_FIXTURES + [
-    settings.ROOT_PATH +
-    '../archaeological_files/fixtures/initial_data-fr.json']
+    settings.ROOT_PATH + "../archaeological_files/fixtures/initial_data-fr.json"
+]
 
 CONTEXT_RECORD_FIXTURES = FILE_FIXTURES + [
-    settings.ROOT_PATH +
-    '../archaeological_context_records/fixtures/initial_data-fr.json',
-    settings.ROOT_PATH +
-    '../archaeological_context_records/fixtures/initial_data_relation_type_norel-fr.json',
-    settings.ROOT_PATH +
-    '../archaeological_context_records/fixtures/initial_data_relation_type-fr.json',
-    ]
+    settings.ROOT_PATH
+    + "../archaeological_context_records/fixtures/initial_data-fr.json",
+    settings.ROOT_PATH
+    + "../archaeological_context_records/fixtures/initial_data_relation_type_norel-fr.json",
+    settings.ROOT_PATH
+    + "../archaeological_context_records/fixtures/initial_data_relation_type-fr.json",
+]
 
 CONTEXT_RECORD_TOWNS_FIXTURES = FILE_TOWNS_FIXTURES + [
-    settings.ROOT_PATH +
-    '../archaeological_context_records/fixtures/initial_data-fr.json',
-    settings.ROOT_PATH +
-    '../archaeological_context_records/fixtures/initial_data_relation_type_norel-fr.json',
-    settings.ROOT_PATH +
-    '../archaeological_context_records/fixtures/initial_data_relation_type-fr.json',
-    ]
+    settings.ROOT_PATH
+    + "../archaeological_context_records/fixtures/initial_data-fr.json",
+    settings.ROOT_PATH
+    + "../archaeological_context_records/fixtures/initial_data_relation_type_norel-fr.json",
+    settings.ROOT_PATH
+    + "../archaeological_context_records/fixtures/initial_data_relation_type-fr.json",
+]
 
 FIND_FIXTURES = CONTEXT_RECORD_FIXTURES + [
-    settings.ROOT_PATH +
-    '../archaeological_finds/fixtures/initial_data-fr.json',
-    ]
+    settings.ROOT_PATH + "../archaeological_finds/fixtures/initial_data-fr.json",
+]
 
 FIND_TOWNS_FIXTURES = CONTEXT_RECORD_TOWNS_FIXTURES + [
-    settings.ROOT_PATH +
-    '../archaeological_finds/fixtures/initial_data-fr.json',
-    ]
+    settings.ROOT_PATH + "../archaeological_finds/fixtures/initial_data-fr.json",
+]
 
 WAREHOUSE_FIXTURES = FIND_FIXTURES + [
-    settings.ROOT_PATH +
-    '../archaeological_warehouse/fixtures/initial_data-fr.json',
-    ]
+    settings.ROOT_PATH + "../archaeological_warehouse/fixtures/initial_data-fr.json",
+]
 
 
 def create_superuser():
-    username = 'username4277'
-    password = 'dcbqj756456!@%'
+    username = "username4277"
+    password = "dcbqj756456!@%"
     q = User.objects.filter(username=username)
     if q.count():
         return username, password, q.all()[0]
-    user = User.objects.create_superuser(username, "nomail@nomail.com",
-                                         password)
+    user = User.objects.create_superuser(username, "nomail@nomail.com", password)
     user.set_password(password)
     user.save()
     return username, password, user
 
 
-def create_user(username='username678', password='dcbqj756aaa456!@%'):
+def create_user(username="username678", password="dcbqj756aaa456!@%"):
     q = User.objects.filter(username=username)
     if q.count():
         return username, password, q.all()[0]
@@ -163,62 +171,31 @@ class TestCase(BaseTestCase):
 
 class UtilsTest(TestCase):
     def test_update_data(self):
-        data_1 = {
-            'old':
-                {'youpi':
-                     {'plouf': 'tralalalère'}}
-        }
-        data_2 = {
-            'tsoin_tsoin': 'hop',
-            'old':
-                {'hoppy': 'hop'}
-        }
+        data_1 = {"old": {"youpi": {"plouf": "tralalalère"}}}
+        data_2 = {"tsoin_tsoin": "hop", "old": {"hoppy": "hop"}}
         expected = {
-            'tsoin_tsoin': 'hop',
-            'old':
-                {'youpi':
-                     {'plouf': 'tralalalère'},
-                 'hoppy': 'hop'}
+            "tsoin_tsoin": "hop",
+            "old": {"youpi": {"plouf": "tralalalère"}, "hoppy": "hop"},
         }
         res = update_data(data_1, data_2)
         self.assertEqual(res, expected)
 
     def test_move_dict_data(self):
-        data = {
-            'old': {'daté': "value"}
-        }
-        expected = {
-            'old': {'date': "value"}
-        }
-        res = move_dict_data(
-            data, 'data__old__daté', "data__old__date")
+        data = {"old": {"daté": "value"}}
+        expected = {"old": {"date": "value"}}
+        res = move_dict_data(data, "data__old__daté", "data__old__date")
         self.assertEqual(res, expected)
-        data = {
-            '': {'hop': "value"}
-        }
-        expected = {
-            'hop': "value",
-            '': {}
-        }
-        res = move_dict_data(data, 'data____hop', "data__hop")
+        data = {"": {"hop": "value"}}
+        expected = {"hop": "value", "": {}}
+        res = move_dict_data(data, "data____hop", "data__hop")
         self.assertEqual(res, expected)
-        data = {
-            'old': {
-                  'traitement': {
-                      'constat_état': 'aaa'
-                  }
-            }
-        }
-        expected = {
-            'old': {
-                'traitement': {
-                    'constat_etat': 'aaa'
-                }
-            }
-        }
-        res = move_dict_data(data,
-                             'data__old__traitement__constat_état',
-                             'data__old__traitement__constat_etat')
+        data = {"old": {"traitement": {"constat_état": "aaa"}}}
+        expected = {"old": {"traitement": {"constat_etat": "aaa"}}}
+        res = move_dict_data(
+            data,
+            "data__old__traitement__constat_état",
+            "data__old__traitement__constat_etat",
+        )
         self.assertEqual(res, expected)
 
     def test_tinyfy_url(self):
@@ -235,44 +212,44 @@ class UtilsTest(TestCase):
             ty = models.TinyUrl.objects.get(id=db_id)
             self.assertEqual(base_url, ty.link)
             c = Client()
-            response = c.get(reverse('tiny-redirect', args=[short_id]))
-            self.assertEqual(response['Location'], base_url)
+            response = c.get(reverse("tiny-redirect", args=[short_id]))
+            self.assertEqual(response["Location"], base_url)
             self.assertEqual(response.status_code, 302)
 
 
 class SearchText:
-    SEARCH_URL = ''
+    SEARCH_URL = ""
 
     def _test_search(self, client, result, context=""):
         assert self.SEARCH_URL
         for q, expected_result in result:
-            search = {'search_vector': q}
+            search = {"search_vector": q}
             response = client.get(reverse(self.SEARCH_URL), search)
             self.assertEqual(response.status_code, 200)
             res = json.loads(response.content.decode())
-            msg = "{} result(s) where expected for search: {} - found {}" \
-                  "".format(expected_result, q, res['recordsTotal'])
+            msg = "{} result(s) where expected for search: {} - found {}" "".format(
+                expected_result, q, res["recordsTotal"]
+            )
             if context:
                 msg = context + " - " + msg
-            self.assertEqual(res['recordsTotal'], expected_result,
-                             msg=msg)
+            self.assertEqual(res["recordsTotal"], expected_result, msg=msg)
 
 
 class CommandsTestCase(TestCase):
-    fixtures = [settings.ROOT_PATH +
-                '../ishtar_common/fixtures/test_towns.json']
+    fixtures = [settings.ROOT_PATH + "../ishtar_common/fixtures/test_towns.json"]
 
     def test_clean_ishtar(self):
         """
         Clean ishtar db
         """
         from archaeological_operations.models import Parcel
+
         p = Parcel.objects.create(
-            town=models.Town.objects.create(name='test', numero_insee='25000'),
+            town=models.Town.objects.create(name="test", numero_insee="25000"),
         )
         parcel_nb = Parcel.objects.count()
         out = StringIO()
-        call_command('clean_ishtar', stdout=out)
+        call_command("clean_ishtar", stdout=out)
         # no operation or file attached - the parcel should have disappear
         self.assertEqual(parcel_nb - 1, Parcel.objects.count())
         self.assertEqual(Parcel.objects.filter(pk=p.pk).count(), 0)
@@ -281,56 +258,75 @@ class CommandsTestCase(TestCase):
         q = models.Town.objects
         town_nb = q.count()
         out = StringIO()
-        call_command('import_geofla_csv',
-                     settings.ROOT_PATH +
-                     '../ishtar_common/tests/geofla-test.csv', '--quiet',
-                     stdout=out)
+        call_command(
+            "import_geofla_csv",
+            settings.ROOT_PATH + "../ishtar_common/tests/geofla-test.csv",
+            "--quiet",
+            stdout=out,
+        )
         self.assertEqual(town_nb + 9, models.Town.objects.count())
-        call_command('import_geofla_csv',
-                     settings.ROOT_PATH +
-                     '../ishtar_common/tests/geofla-test.csv', '--quiet',
-                     stdout=out)
+        call_command(
+            "import_geofla_csv",
+            settings.ROOT_PATH + "../ishtar_common/tests/geofla-test.csv",
+            "--quiet",
+            stdout=out,
+        )
         # no new town
         self.assertEqual(town_nb + 9, models.Town.objects.count())
 
     def test_import_insee(self):
         q = models.Town.objects
         town_nb = q.count()
-        first, union_start, union_end = '', '', []
+        first, union_start, union_end = "", "", []
         new_nums = []
         for idx, town in enumerate(q.all()):
             x1 = float(idx) / 10
             if not x1:
                 x1 = 0
             x2 = float(idx) / 10 + 0.1
-            l = 'MULTIPOLYGON((({x1} 0.1,{x2} 0.1,{x2} 0,{x1} 0,' \
-                '{x1} 0.1)))'.format(x1=x1, x2=x2)
+            l = "MULTIPOLYGON((({x1} 0.1,{x2} 0.1,{x2} 0,{x1} 0," "{x1} 0.1)))".format(
+                x1=x1, x2=x2
+            )
             if union_start:
                 union_start += ", "
             else:
-                first = '{x1} 0.1'.format(x1=x1)
-            union_start += '{x2} 0.1'.format(x1=x1, x2=x2)
-            union_end.append('{x2} 0'.format(x1=x1, x2=x2))
+                first = "{x1} 0.1".format(x1=x1)
+            union_start += "{x2} 0.1".format(x1=x1, x2=x2)
+            union_end.append("{x2} 0".format(x1=x1, x2=x2))
             town.limit = l
             town.year = 1792
             new_nums.append("{}-{}".format(town.numero_insee, town.year))
             town.save()
-        union = 'MULTIPOLYGON (((' + first + ", " + union_start + \
-            ", " + ", ".join(reversed(union_end)) + ", 0 0, " + first + ")))"
+        union = (
+            "MULTIPOLYGON ((("
+            + first
+            + ", "
+            + union_start
+            + ", "
+            + ", ".join(reversed(union_end))
+            + ", 0 0, "
+            + first
+            + ")))"
+        )
         out = StringIO()
-        call_command('import_insee_comm_csv',
-                     settings.ROOT_PATH +
-                     '../ishtar_common/tests/insee-test.csv', '--quiet',
-                     stdout=out)
+        call_command(
+            "import_insee_comm_csv",
+            settings.ROOT_PATH + "../ishtar_common/tests/insee-test.csv",
+            "--quiet",
+            stdout=out,
+        )
         self.assertEqual(town_nb + 1, models.Town.objects.count())
-        new = models.Town.objects.order_by('-pk').all()[0]
+        new = models.Town.objects.order_by("-pk").all()[0]
         self.assertEqual(new.parents.count(), 2)
 
         self.assertEqual(new.limit.wkt, union)
 
-        call_command('import_insee_comm_csv', '--quiet',
-                     settings.ROOT_PATH +
-                     '../ishtar_common/tests/insee-test.csv', stdout=out)
+        call_command(
+            "import_insee_comm_csv",
+            "--quiet",
+            settings.ROOT_PATH + "../ishtar_common/tests/insee-test.csv",
+            stdout=out,
+        )
         # no new town
         self.assertEqual(town_nb + 1, models.Town.objects.count())
 
@@ -342,8 +338,16 @@ class WizardTestFormData(object):
     """
     Test set to simulate wizard steps
     """
-    def __init__(self, name, form_datas=None, ignored=None, pre_tests=None,
-                 extra_tests=None, error_expected=None):
+
+    def __init__(
+        self,
+        name,
+        form_datas=None,
+        ignored=None,
+        pre_tests=None,
+        extra_tests=None,
+        error_expected=None,
+    ):
         """
         :param name: explicit name of the test
         :param form_datas: dict with data for each step - dict key are wizard
@@ -392,7 +396,7 @@ class WizardTestFormData(object):
         Initialisations before the wizard.
         """
 
-        suffix = '-' + test_object.url_name
+        suffix = "-" + test_object.url_name
         # if form names are defined without url_name fix it
         for form_name in list(self.form_datas.keys()):
             if suffix in form_name:
@@ -412,7 +416,6 @@ class WizardTestFormData(object):
 
 
 class TimedTextTestResult(TextTestResult):
-
     def __init__(self, *args, **kwargs):
         super(TimedTextTestResult, self).__init__(*args, **kwargs)
         self.clocks = {}
@@ -430,7 +433,7 @@ class TimedTextTestResult(TextTestResult):
         if self.showAll:
             self.stream.writeln("OK (%.6fs)" % (time() - self.clocks[test]))
         elif self.dots:
-            self.stream.write('.')
+            self.stream.write(".")
             self.stream.flush()
 
 
@@ -444,20 +447,19 @@ class ManagedModelTestRunner(DiscoverRunner):
     project managed for the duration of the test run, so that one doesn't need
     to execute the SQL manually to create them.
     """
+
     test_runner = TimedTextTestRunner
 
     def setup_test_environment(self, *args, **kwargs):
         from django.apps import apps
-        self.unmanaged_models = [m for m in apps.get_models()
-                                 if not m._meta.managed]
+
+        self.unmanaged_models = [m for m in apps.get_models() if not m._meta.managed]
         for m in self.unmanaged_models:
             m._meta.managed = True
-        super(ManagedModelTestRunner, self).setup_test_environment(*args,
-                                                                   **kwargs)
+        super(ManagedModelTestRunner, self).setup_test_environment(*args, **kwargs)
 
     def teardown_test_environment(self, *args, **kwargs):
-        super(ManagedModelTestRunner, self).teardown_test_environment(*args,
-                                                                      **kwargs)
+        super(ManagedModelTestRunner, self).teardown_test_environment(*args, **kwargs)
         # reset unmanaged models
         for m in self.unmanaged_models:
             m._meta.managed = False
@@ -466,7 +468,7 @@ class ManagedModelTestRunner(DiscoverRunner):
 class WizardTest(object):
     url_name = None
     url_uri = None
-    wizard_name = ''
+    wizard_name = ""
     steps = None
     condition_dict = None
     form_datas = []
@@ -479,8 +481,7 @@ class WizardTest(object):
         self.username, self.password, self.user = create_superuser()
 
     def pre_wizard(self):
-        self.client.login(**{'username': self.username,
-                             'password': self.password})
+        self.client.login(**{"username": self.username, "password": self.password})
 
     def post_wizard(self):
         pass
@@ -491,22 +492,24 @@ class WizardTest(object):
     def check_response(self, response, current_step, data_idx):
         if "errorlist" in response.content.decode():
             soup = Soup(response.content.decode(), "lxml")
-            errorlist = soup.findAll(
-                "ul", {"class": "errorlist"})
+            errorlist = soup.findAll("ul", {"class": "errorlist"})
             errors = []
             for li in errorlist:
                 lbl = li.findParent().findParent().findChild().text
                 errors.append("{} - {}".format(lbl, li.text))
-            raise ValidationError("Errors: {} on {} - dataset {}.".format(
-                " ".join(errors), current_step, data_idx + 1))
+            raise ValidationError(
+                "Errors: {} on {} - dataset {}.".format(
+                    " ".join(errors), current_step, data_idx + 1
+                )
+            )
 
-    def wizard_post(self, client, url, current_step, form_data=None,
-                    follow=True, extra_data=None):
+    def wizard_post(
+        self, client, url, current_step, form_data=None, follow=True, extra_data=None
+    ):
         if not url:
             url = reverse(self.url_name)
         data = {
-            '{}{}-current_step'.format(self.url_name,
-                                       self.wizard_name): [current_step],
+            "{}{}-current_step".format(self.url_name, self.wizard_name): [current_step],
         }
         if not form_data:
             form_data = []
@@ -515,34 +518,36 @@ class WizardTest(object):
         if type(form_data) in (list, tuple):  # is a formset
             for d_idx, item in enumerate(form_data):
                 for k in item:
-                    data['{}-{}-{}'.format(
-                        current_step, d_idx, k)] = item[k]
+                    data["{}-{}-{}".format(current_step, d_idx, k)] = item[k]
         else:
             for k in form_data:
-                data['{}-{}'.format(current_step, k)] = form_data[k]
+                data["{}-{}".format(current_step, k)] = form_data[k]
         if extra_data:
             data.update(extra_data)
 
         try:
             response = client.post(url, data, follow=follow)
         except ValidationError as e:
-            msg = "Errors: {} on {}. On \"ManagementForm data is " \
-                  "missing or...\" error verify the wizard_name or " \
-                  "step name".format(" - ".join(e.messages),
-                                     current_step)
+            msg = (
+                'Errors: {} on {}. On "ManagementForm data is '
+                'missing or..." error verify the wizard_name or '
+                "step name".format(" - ".join(e.messages), current_step)
+            )
             raise ValidationError(msg)
         return response
 
-    def wizard_post_test(self, idx, data_idx, url, current_step, form_data,
-                         test_form_data, ignored):
-        next_form_is_checked = len(self.steps) > idx + 1 and \
-                               self.steps[idx + 1][0] not in ignored
+    def wizard_post_test(
+        self, idx, data_idx, url, current_step, form_data, test_form_data, ignored
+    ):
+        next_form_is_checked = (
+            len(self.steps) > idx + 1 and self.steps[idx + 1][0] not in ignored
+        )
         data = []
         if current_step in form_data:
             data = form_data[current_step]
         response = self.wizard_post(
-            self.client, url, current_step, data,
-            not next_form_is_checked)
+            self.client, url, current_step, data, not next_form_is_checked
+        )
 
         if current_step == test_form_data.error_expected:
             with self.assertRaises(ValidationError):
@@ -554,23 +559,20 @@ class WizardTest(object):
             next_form = self.steps[idx + 1][0]
             self.assertRedirects(
                 response,
-                '/{}/{}'.format(self.url_uri, next_form),
+                "/{}/{}".format(self.url_uri, next_form),
                 msg_prefix="Dataset n{} Redirection to {} has failed - "
-                           "Error on previous form ({})?".format(
-                    data_idx + 1, next_form, current_step)
+                "Error on previous form ({})?".format(
+                    data_idx + 1, next_form, current_step
+                ),
             )
         if idx == len(self.steps) - 1:
             #  last form
             if not self.redirect_url:
-                redirect_url = '/{}/done'.format(self.url_uri)
+                redirect_url = "/{}/done".format(self.url_uri)
             else:
-                dct = {
-                    "url_name": self.url_name,
-                    "url_uri": self.url_uri
-                }
-                form_key = 'selec-' + self.url_name
-                if form_key in form_data and self.current_id_key in form_data[
-                        form_key]:
+                dct = {"url_name": self.url_name, "url_uri": self.url_uri}
+                form_key = "selec-" + self.url_name
+                if form_key in form_data and self.current_id_key in form_data[form_key]:
                     dct["current_id"] = form_data[form_key][self.current_id_key]
                 if self.model:
                     q = self.model.objects
@@ -601,35 +603,37 @@ class WizardTest(object):
                 elif self.test_back and not back_tested:
                     # test going back on a form
                     response = self.wizard_post(
-                        self.client, url, current_step, None,
-                        extra_data={"form_prev_step": previous_step}
+                        self.client,
+                        url,
+                        current_step,
+                        None,
+                        extra_data={"form_prev_step": previous_step},
                     )
                     self.assertEqual(response.status_code, 200)
                     back_tested = True
                 response = self.wizard_post_test(
-                    idx, data_idx, url, current_step, form_data, test_form_data,
-                    ignored)
+                    idx, data_idx, url, current_step, form_data, test_form_data, ignored
+                )
             test_form_data.tests(self, response)
         self.post_wizard()
 
 
 class CacheTest(TestCase):
-    fixtures = [settings.ROOT_PATH +
-                '../fixtures/initial_data-auth-fr.json',
-                settings.ROOT_PATH +
-                '../ishtar_common/fixtures/initial_data-fr.json',]
+    fixtures = [
+        settings.ROOT_PATH + "../fixtures/initial_data-auth-fr.json",
+        settings.ROOT_PATH + "../ishtar_common/fixtures/initial_data-fr.json",
+    ]
 
     def test_add(self):
         models.OrganizationType.refresh_cache()
-        cached = models.OrganizationType.get_cache('test')
+        cached = models.OrganizationType.get_cache("test")
         self.assertEqual(cached, None)
-        orga = models.OrganizationType.objects.create(
-            txt_idx='test', label='testy')
-        cached = models.OrganizationType.get_cache('test')
+        orga = models.OrganizationType.objects.create(txt_idx="test", label="testy")
+        cached = models.OrganizationType.get_cache("test")
         self.assertEqual(cached.pk, orga.pk)
-        orga.txt_idx = 'testy'
+        orga.txt_idx = "testy"
         orga.save()
-        cached = models.OrganizationType.get_cache('testy')
+        cached = models.OrganizationType.get_cache("testy")
         self.assertEqual(cached.pk, orga.pk)
 
     def test_list(self):
@@ -637,30 +641,30 @@ class CacheTest(TestCase):
         types = models.OrganizationType.get_types()
         # only empty
         self.assertTrue(len(types), 1)
-        org = models.OrganizationType.objects.create(
-            txt_idx='test', label='testy')
-        types = [
-            str(lbl) for idx, lbl in models.OrganizationType.get_types()]
-        self.assertTrue('testy' in types)
+        org = models.OrganizationType.objects.create(txt_idx="test", label="testy")
+        types = [str(lbl) for idx, lbl in models.OrganizationType.get_types()]
+        self.assertTrue("testy" in types)
         org.delete()
-        types = [
-            str(lbl) for idx, lbl in models.OrganizationType.get_types()]
-        self.assertFalse('testy' in types)
+        types = [str(lbl) for idx, lbl in models.OrganizationType.get_types()]
+        self.assertFalse("testy" in types)
 
     def test_menu_cache(self):
-        admin_username = 'username4277'
-        admin_password = 'dcbqj756456!@%'
-        User.objects.create_superuser(admin_username, "nomail@nomail.com",
-                                      admin_password)
-        readonly_user = 'username4456'
-        readonly_password = 'xshqu744456!@%'
-        user = User.objects.create_user(readonly_user, "nomail@nomail.com",
-                                        readonly_password)
+        admin_username = "username4277"
+        admin_password = "dcbqj756456!@%"
+        User.objects.create_superuser(
+            admin_username, "nomail@nomail.com", admin_password
+        )
+        readonly_user = "username4456"
+        readonly_password = "xshqu744456!@%"
+        user = User.objects.create_user(
+            readonly_user, "nomail@nomail.com", readonly_password
+        )
         ishtuser = models.IshtarUser.objects.get(user_ptr=user)
         models.UserProfile.objects.get_or_create(
-            current=True, person=ishtuser.person,
-            profile_type=models.ProfileType.objects.get(
-                txt_idx='reader_access'))
+            current=True,
+            person=ishtuser.person,
+            profile_type=models.ProfileType.objects.get(txt_idx="reader_access"),
+        )
 
         c = Client()
         c.login(username=admin_username, password=admin_password)
@@ -680,17 +684,22 @@ class CacheTest(TestCase):
 
 class GenericSerializationTest:
     def create_document_default(self):
-        image_path = os.path.join(settings.ROOT_PATH, "..", "ishtar_common",
-                                  "tests", "test.png")
+        image_path = os.path.join(
+            settings.ROOT_PATH, "..", "ishtar_common", "tests", "test.png"
+        )
         self.documents = []
         for idx in range(12):
-            self.documents.append(models.Document.objects.create(
-                title="Test{}".format(idx),
-                associated_file=SimpleUploadedFile(
-                    'test.txt', b'no real content'),
-                image=SimpleUploadedFile(
-                    name='test.png', content=open(image_path, 'rb').read(),
-                    content_type='image/png')))
+            self.documents.append(
+                models.Document.objects.create(
+                    title="Test{}".format(idx),
+                    associated_file=SimpleUploadedFile("test.txt", b"no real content"),
+                    image=SimpleUploadedFile(
+                        name="test.png",
+                        content=open(image_path, "rb").read(),
+                        content_type="image/png",
+                    ),
+                )
+            )
 
     def generic_serialization_test(self, serialize, no_test=False, kwargs=None):
         if not kwargs:
@@ -703,11 +712,11 @@ class GenericSerializationTest:
             module_name, model_name = k.split("__")
             if module_name == "django":
                 if model_name in ("Group", "Permission"):
-                    module = importlib.import_module(
-                        "django.contrib.auth.models")
+                    module = importlib.import_module("django.contrib.auth.models")
                 elif model_name in ("ContentType",):
                     module = importlib.import_module(
-                        "django.contrib.contenttypes.models")
+                        "django.contrib.contenttypes.models"
+                    )
                 else:
                     return
             else:
@@ -720,62 +729,87 @@ class GenericSerializationTest:
             result = json.loads(json_result[key])
             serialization_count = len(result)
             # all serialization have to be tested
-            self.assertTrue(serialization_count,
-                            msg="No data to test for {}".format(key))
+            self.assertTrue(
+                serialization_count, msg="No data to test for {}".format(key)
+            )
             # only "natural" serialization
             self.assertNotIn(
-                "pk", result[0],
-                msg="Serialization for {} do not use natural keys".format(key))
+                "pk",
+                result[0],
+                msg="Serialization for {} do not use natural keys".format(key),
+            )
             self.assertNotIn(
-                "id", result[0],
-                msg="Serialization for {} do not use natural keys".format(key))
+                "id",
+                result[0],
+                msg="Serialization for {} do not use natural keys".format(key),
+            )
             # has to be at least equal (can be superior for model with
             # recursion)
             self.assertTrue(
                 serialization_count >= current_count,
                 msg="Serialization for model {}.{} failed. {} serialized {} "
-                    "expected".format(module.__name__, model_name,
-                                      serialization_count, current_count))
+                "expected".format(
+                    module.__name__, model_name, serialization_count, current_count
+                ),
+            )
         return json_result
 
-    def generic_restore_test_genzip(self, model_list, serialization,
-                                    kwargs=None):
+    def generic_restore_test_genzip(self, model_list, serialization, kwargs=None):
         current_number = {}
         for model in model_list:
-            current_number[(model.__module__, model.__name__)] = \
-                model.objects.count()
+            current_number[(model.__module__, model.__name__)] = model.objects.count()
         if not kwargs:
             kwargs = {}
         kwargs["archive"] = True
         zip_filename = serialization(**kwargs)
         return current_number, zip_filename
 
-    def generic_restore_test(self, zip_filename, current_number, model_list,
-                             release_locks=False, delete_existing=True):
-        restore_serialized(zip_filename, delete_existing=delete_existing,
-                           release_locks=release_locks)
+    def generic_restore_test(
+        self,
+        zip_filename,
+        current_number,
+        model_list,
+        release_locks=False,
+        delete_existing=True,
+    ):
+        restore_serialized(
+            zip_filename, delete_existing=delete_existing, release_locks=release_locks
+        )
         for model in model_list:
             previous_nb = current_number[(model.__module__, model.__name__)]
             current_nb = model.objects.count()
             self.assertEqual(
-                previous_nb, current_nb,
+                previous_nb,
+                current_nb,
                 msg="Restore for model {}.{} failed. Initial: {}, restored: "
-                    "{}.".format(model.__module__, model.__name__,
-                                 previous_nb, current_nb))
+                "{}.".format(model.__module__, model.__name__, previous_nb, current_nb),
+            )
 
 
 class SerializationTest(GenericSerializationTest, TestCase):
     fixtures = COMMON_FIXTURES + WAREHOUSE_FIXTURES
 
     def create_types(self):
-        from archaeological_finds.models import MaterialTypeQualityType, \
-            ObjectTypeQualityType, AlterationType, AlterationCauseType, \
-            TreatmentEmergencyType, CommunicabilityType
+        from archaeological_finds.models import (
+            MaterialTypeQualityType,
+            ObjectTypeQualityType,
+            AlterationType,
+            AlterationCauseType,
+            TreatmentEmergencyType,
+            CommunicabilityType,
+        )
         from archaeological_operations.models import CulturalAttributionType
-        for model in (models.LicenseType, MaterialTypeQualityType,
-                      ObjectTypeQualityType, AlterationType,
-                      AlterationCauseType, TreatmentEmergencyType,
-                      CommunicabilityType, CulturalAttributionType):
+
+        for model in (
+            models.LicenseType,
+            MaterialTypeQualityType,
+            ObjectTypeQualityType,
+            AlterationType,
+            AlterationCauseType,
+            TreatmentEmergencyType,
+            CommunicabilityType,
+            CulturalAttributionType,
+        ):
             model.objects.create(txt_idx="test", label="Test")
 
     def test_type_serialization(self):
@@ -787,9 +821,9 @@ class SerializationTest(GenericSerializationTest, TestCase):
         models.get_current_profile(force=True)  # create a default profile
         models.GlobalVar.objects.create(slug="test")
         cform = models.CustomForm.objects.create(
-            name="Test", form='ishtar_common.forms.TestForm')
-        models.ExcludedField.objects.create(custom_form=cform,
-                                            field="ExcludedField")
+            name="Test", form="ishtar_common.forms.TestForm"
+        )
+        models.ExcludedField.objects.create(custom_form=cform, field="ExcludedField")
         CT = ContentType.objects.get_for_model(models.OrganizationType)
         models.JsonDataSection.objects.create(
             content_type=CT,
@@ -805,8 +839,10 @@ class SerializationTest(GenericSerializationTest, TestCase):
             klass="ishtar_common.models.Organization"
         )
         values["document_template"] = models.DocumentTemplate.objects.create(
-            name="Test", slug="test", associated_model=mod,
-            template=SimpleUploadedFile('test.txt', b'no real content')
+            name="Test",
+            slug="test",
+            associated_model=mod,
+            template=SimpleUploadedFile("test.txt", b"no real content"),
         )
         return values
 
@@ -825,20 +861,21 @@ class SerializationTest(GenericSerializationTest, TestCase):
 
     def create_geo_default(self):
         s = models_common.State.objects.create(label="test", number="999")
-        d = models.Department.objects.create(label="test", number="999",
-                                             state=s)
+        d = models.Department.objects.create(label="test", number="999", state=s)
         t1 = models.Town.objects.create(
             name="Test town",
             center="SRID=4326;POINT(-44.3 60.1)",
-            numero_insee="12345", departement=d
+            numero_insee="12345",
+            departement=d,
         )
         t2 = models.Town.objects.create(
             name="Test town 2",
             center="SRID=4326;POINT(-44.2 60.2)",
-            numero_insee="12346", departement=d
+            numero_insee="12346",
+            departement=d,
         )
         t2.children.add(t1)
-        a = models.Area.objects.create(label="Test", txt_idx='test')
+        a = models.Area.objects.create(label="Test", txt_idx="test")
         a.towns.add(t1)
 
     def test_geo_serialization(self):
@@ -847,13 +884,12 @@ class SerializationTest(GenericSerializationTest, TestCase):
 
     def create_directory_default(self):
         org = models.Organization.objects.create(
-            name="Test",
-            organization_type=models.OrganizationType.objects.all()[0])
-        person = models.Person.objects.create(
-            name="Test", attached_to=org
+            name="Test", organization_type=models.OrganizationType.objects.all()[0]
         )
+        person = models.Person.objects.create(name="Test", attached_to=org)
         models.Author.objects.create(
-            person=person, author_type=models.AuthorType.objects.all()[0])
+            person=person, author_type=models.AuthorType.objects.all()[0]
+        )
 
     def test_directory_serialization(self):
         self.create_directory_default()
@@ -861,17 +897,29 @@ class SerializationTest(GenericSerializationTest, TestCase):
 
     def create_document_default(self):
         super(SerializationTest, self).create_document_default()
-        from archaeological_operations.models import Operation, \
-            ArchaeologicalSite, OperationType
+        from archaeological_operations.models import (
+            Operation,
+            ArchaeologicalSite,
+            OperationType,
+        )
         from archaeological_context_records.models import ContextRecord
         from archaeological_finds.models import Find, BaseFind
-        from archaeological_warehouse.models import Warehouse, Container, \
-            ContainerLocalisation, WarehouseDivision, WarehouseDivisionLink, \
-            WarehouseType, ContainerType
+        from archaeological_warehouse.models import (
+            Warehouse,
+            Container,
+            ContainerLocalisation,
+            WarehouseDivision,
+            WarehouseDivisionLink,
+            WarehouseType,
+            ContainerType,
+        )
 
         operation_type = OperationType.objects.all()[0]
-        dct = {'year': 2010, 'operation_type_id': operation_type.pk,
-               "code_patriarche": "66666"}
+        dct = {
+            "year": 2010,
+            "operation_type_id": operation_type.pk,
+            "code_patriarche": "66666",
+        }
         operation1 = Operation.objects.create(**dct)
         operation1.documents.add(self.documents[0])
         dct["code_patriarche"] = "66667"
@@ -885,23 +933,23 @@ class SerializationTest(GenericSerializationTest, TestCase):
         operation2.archaeological_sites.add(site2)
         site2.documents.add(self.documents[3])
 
-        dct = {'label': "Context record1", "operation": operation1}
+        dct = {"label": "Context record1", "operation": operation1}
         cr1 = ContextRecord.objects.create(**dct)
         cr1.documents.add(self.documents[4])
-        dct = {'label': "Context record2", "operation": operation2}
+        dct = {"label": "Context record2", "operation": operation2}
         cr2 = ContextRecord.objects.create(**dct)
         cr2.documents.add(self.documents[5])
 
-        dct = {'label': "Base find", "context_record": cr1}
+        dct = {"label": "Base find", "context_record": cr1}
         base_find1 = BaseFind.objects.create(**dct)
-        dct = {'label': "Base find2", "context_record": cr2}
+        dct = {"label": "Base find2", "context_record": cr2}
         base_find2 = BaseFind.objects.create(**dct)
 
-        dct = {'label': "Find1"}
+        dct = {"label": "Find1"}
         find1 = Find.objects.create(**dct)
         find1.documents.add(self.documents[6])
         find1.base_finds.add(base_find1)
-        dct = {'label': "Find2"}
+        dct = {"label": "Find2"}
         find2 = Find.objects.create(**dct)
         find2.documents.add(self.documents[7])
         find2.base_finds.add(base_find2)
@@ -925,7 +973,7 @@ class SerializationTest(GenericSerializationTest, TestCase):
             container_type=ContainerType.objects.all()[0],
             reference="Réf1",
             index=1,
-            external_id="ref1-1"
+            external_id="ref1-1",
         )
         c1.documents.add(self.documents[10])
         c2 = Container.objects.create(
@@ -934,7 +982,7 @@ class SerializationTest(GenericSerializationTest, TestCase):
             container_type=ContainerType.objects.all()[0],
             reference="Réf2",
             index=2,
-            external_id="ref2-2"
+            external_id="ref2-2",
         )
         c2.documents.add(self.documents[11])
         find1.container = c1
@@ -943,30 +991,18 @@ class SerializationTest(GenericSerializationTest, TestCase):
         find2.container = c2
         find2.container_ref = c2
         find2.save()
-        wd1 = WarehouseDivision.objects.create(
-            label="Étagère", txt_idx="etagere"
-        )
-        wd2 = WarehouseDivision.objects.create(
-            label="Allée", txt_idx="allee"
-        )
+        wd1 = WarehouseDivision.objects.create(label="Étagère", txt_idx="etagere")
+        wd2 = WarehouseDivision.objects.create(label="Allée", txt_idx="allee")
         wl1 = WarehouseDivisionLink.objects.create(
             warehouse=w1,
             container_type=ContainerType.objects.all()[0],
         )
         wl2 = WarehouseDivisionLink.objects.create(
             warehouse=w2,
-            container_type = ContainerType.objects.all()[1],
-        )
-        ContainerLocalisation.objects.create(
-            container=c1,
-            division=wl1,
-            reference="A1"
-        )
-        ContainerLocalisation.objects.create(
-            container=c2,
-            division=wl2,
-            reference="A2"
+            container_type=ContainerType.objects.all()[1],
         )
+        ContainerLocalisation.objects.create(container=c1, division=wl1, reference="A1")
+        ContainerLocalisation.objects.create(container=c2, division=wl2, reference="A2")
 
     def test_base_document_serialization(self):
         self.create_document_default()
@@ -974,71 +1010,65 @@ class SerializationTest(GenericSerializationTest, TestCase):
 
     def test_document_serialization(self):
         self.create_document_default()
-        res = self.generic_serialization_test(
-            document_serialization)
-        docs = json.loads(
-            res[('documents', 'ishtar_common__Document')]
-        )
+        res = self.generic_serialization_test(document_serialization)
+        docs = json.loads(res[("documents", "ishtar_common__Document")])
         self.assertEqual(len(docs), 12)
 
-        from archaeological_operations.models import Operation, \
-            ArchaeologicalSite
-        result_queryset = Operation.objects.filter(
-            code_patriarche="66666")
+        from archaeological_operations.models import Operation, ArchaeologicalSite
+
+        result_queryset = Operation.objects.filter(code_patriarche="66666")
         res = self.generic_serialization_test(
-            document_serialization, no_test=True,
-            kwargs={"operation_queryset": result_queryset}
-        )
-        docs = json.loads(
-            res[('documents', 'ishtar_common__Document')]
+            document_serialization,
+            no_test=True,
+            kwargs={"operation_queryset": result_queryset},
         )
+        docs = json.loads(res[("documents", "ishtar_common__Document")])
         self.assertEqual(len(docs), 6)
 
         result_queryset = ArchaeologicalSite.objects.filter(
-            id=ArchaeologicalSite.objects.all()[0].id)
-        res = self.generic_serialization_test(
-            document_serialization, no_test=True,
-            kwargs={"site_queryset": result_queryset}
+            id=ArchaeologicalSite.objects.all()[0].id
         )
-        docs = json.loads(
-            res[('documents', 'ishtar_common__Document')]
+        res = self.generic_serialization_test(
+            document_serialization,
+            no_test=True,
+            kwargs={"site_queryset": result_queryset},
         )
+        docs = json.loads(res[("documents", "ishtar_common__Document")])
         self.assertEqual(len(docs), 6)
 
         from archaeological_context_records.models import ContextRecord
+
         result_queryset = ContextRecord.objects.filter(
-            id=ContextRecord.objects.all()[0].id)
-        res = self.generic_serialization_test(
-            document_serialization, no_test=True,
-            kwargs={"cr_queryset": result_queryset}
+            id=ContextRecord.objects.all()[0].id
         )
-        docs = json.loads(
-            res[('documents', 'ishtar_common__Document')]
+        res = self.generic_serialization_test(
+            document_serialization,
+            no_test=True,
+            kwargs={"cr_queryset": result_queryset},
         )
+        docs = json.loads(res[("documents", "ishtar_common__Document")])
         self.assertEqual(len(docs), 6)
 
         from archaeological_finds.models import Find
-        result_queryset = Find.objects.filter(
-            id=Find.objects.all()[0].id)
+
+        result_queryset = Find.objects.filter(id=Find.objects.all()[0].id)
         res = self.generic_serialization_test(
-            document_serialization, no_test=True,
-            kwargs={"find_queryset": result_queryset}
-        )
-        docs = json.loads(
-            res[('documents', 'ishtar_common__Document')]
+            document_serialization,
+            no_test=True,
+            kwargs={"find_queryset": result_queryset},
         )
+        docs = json.loads(res[("documents", "ishtar_common__Document")])
         self.assertEqual(len(docs), 6)
 
         from archaeological_warehouse.models import Warehouse
-        result_queryset = Warehouse.objects.filter(
-            id=Warehouse.objects.all()[0].id)
+
+        result_queryset = Warehouse.objects.filter(id=Warehouse.objects.all()[0].id)
         res = self.generic_serialization_test(
-            document_serialization, no_test=True,
-            kwargs={"warehouse_queryset": result_queryset}
-        )
-        docs = json.loads(
-            res[('documents', 'ishtar_common__Document')]
+            document_serialization,
+            no_test=True,
+            kwargs={"warehouse_queryset": result_queryset},
         )
+        docs = json.loads(res[("documents", "ishtar_common__Document")])
         self.assertEqual(len(docs), 6)
 
     def test_serialization_zip(self):
@@ -1067,6 +1097,7 @@ class SerializationTest(GenericSerializationTest, TestCase):
     def test_type_restore(self):
         from archaeological_context_records.models import RelationType as CRRT
         from archaeological_operations.models import RelationType as OperationRT
+
         cr_rel_type_nb = CRRT.objects.count()
         ope_rel_type_nb = OperationRT.objects.count()
         self.create_types()
@@ -1075,75 +1106,76 @@ class SerializationTest(GenericSerializationTest, TestCase):
 
         zip_filename = type_serialization(archive=True)
         models.AuthorType.objects.create(
-            label="Am I still here", txt_idx="am-i-still-here")
+            label="Am I still here", txt_idx="am-i-still-here"
+        )
         models.AuthorType.objects.filter(txt_idx="test").delete()
         restore_serialized(zip_filename)
+        self.assertEqual(models.AuthorType.objects.filter(txt_idx="test").count(), 1)
         self.assertEqual(
-            models.AuthorType.objects.filter(txt_idx="test").count(), 1)
-        self.assertEqual(
-            models.AuthorType.objects.filter(txt_idx="am-i-still-here").count(),
-            1)
+            models.AuthorType.objects.filter(txt_idx="am-i-still-here").count(), 1
+        )
         self.assertEqual(cr_rel_type_nb, CRRT.objects.count())
         self.assertEqual(ope_rel_type_nb, OperationRT.objects.count())
-        self.assertTrue(OperationRT.objects.filter(
-            inverse_relation__isnull=False).count())
+        self.assertTrue(
+            OperationRT.objects.filter(inverse_relation__isnull=False).count()
+        )
 
         models.AuthorType.objects.filter(txt_idx="am-i-still-here").delete()
         zip_filename = type_serialization(archive=True)
         models.AuthorType.objects.create(
-            label="Am I still here", txt_idx="am-i-still-here")
+            label="Am I still here", txt_idx="am-i-still-here"
+        )
         models.AuthorType.objects.filter(txt_idx="test").delete()
         restore_serialized(zip_filename, delete_existing=True)
+        self.assertEqual(models.AuthorType.objects.filter(txt_idx="test").count(), 1)
         self.assertEqual(
-            models.AuthorType.objects.filter(txt_idx="test").count(), 1)
-        self.assertEqual(
-            models.AuthorType.objects.filter(txt_idx="am-i-still-here").count(),
-            0)
+            models.AuthorType.objects.filter(txt_idx="am-i-still-here").count(), 0
+        )
         self.assertEqual(cr_rel_type_nb, CRRT.objects.count())
         self.assertEqual(ope_rel_type_nb, OperationRT.objects.count())
-        self.assertTrue(OperationRT.objects.filter(
-            inverse_relation__isnull=False).count())
+        self.assertTrue(
+            OperationRT.objects.filter(inverse_relation__isnull=False).count()
+        )
 
     def test_conf_restore(self):
         values = self.create_default_conf()
         current_number, zip_filename = self.generic_restore_test_genzip(
-            CONF_MODEL_LIST, conf_serialization)
+            CONF_MODEL_LIST, conf_serialization
+        )
         os.remove(values["document_template"].template.path)
         self.generic_restore_test(zip_filename, current_number, CONF_MODEL_LIST)
-        self.assertTrue(
-            os.path.isfile(values["document_template"].template.path)
-        )
+        self.assertTrue(os.path.isfile(values["document_template"].template.path))
 
     def test_importer_restore(self):
         self.create_default_importer()
         current_number, zip_filename = self.generic_restore_test_genzip(
-            IMPORT_MODEL_LIST, importer_serialization)
-        self.generic_restore_test(zip_filename, current_number,
-                                  IMPORT_MODEL_LIST)
+            IMPORT_MODEL_LIST, importer_serialization
+        )
+        self.generic_restore_test(zip_filename, current_number, IMPORT_MODEL_LIST)
 
     def test_geo_restore(self):
         self.create_geo_default()
         self.assertTrue(models.Town.objects.get(numero_insee="12345").center)
         current_number, zip_filename = self.generic_restore_test_genzip(
-            GEO_MODEL_LIST, geo_serialization)
-        self.generic_restore_test(zip_filename, current_number,
-                                  GEO_MODEL_LIST)
+            GEO_MODEL_LIST, geo_serialization
+        )
+        self.generic_restore_test(zip_filename, current_number, GEO_MODEL_LIST)
         # no geo restore
         self.assertFalse(models.Town.objects.get(numero_insee="12345").center)
 
     def test_directory_restore(self):
         self.create_directory_default()
         current_number, zip_filename = self.generic_restore_test_genzip(
-            DIRECTORY_MODEL_LIST, directory_serialization)
-        self.generic_restore_test(zip_filename, current_number,
-                                  DIRECTORY_MODEL_LIST)
+            DIRECTORY_MODEL_LIST, directory_serialization
+        )
+        self.generic_restore_test(zip_filename, current_number, DIRECTORY_MODEL_LIST)
 
     def test_document_restore(self):
         self.create_document_default()
         current_number, zip_filename = self.generic_restore_test_genzip(
-            [models.Document], document_serialization)
-        self.generic_restore_test(zip_filename, current_number,
-                                  [models.Document])
+            [models.Document], document_serialization
+        )
+        self.generic_restore_test(zip_filename, current_number, [models.Document])
 
     def full_create(self):
         self.create_types()
@@ -1155,31 +1187,46 @@ class SerializationTest(GenericSerializationTest, TestCase):
 
     def test_full_restore(self):
         self.full_create()
-        model_list = get_type_models() + CONF_MODEL_LIST + IMPORT_MODEL_LIST + \
-            GEO_MODEL_LIST + DIRECTORY_MODEL_LIST + OPERATION_MODEL_LIST + \
-            CR_MODEL_LIST + FIND_MODEL_LIST + WAREHOUSE_MODEL_LIST
+        model_list = (
+            get_type_models()
+            + CONF_MODEL_LIST
+            + IMPORT_MODEL_LIST
+            + GEO_MODEL_LIST
+            + DIRECTORY_MODEL_LIST
+            + OPERATION_MODEL_LIST
+            + CR_MODEL_LIST
+            + FIND_MODEL_LIST
+            + WAREHOUSE_MODEL_LIST
+        )
         current_number, zip_filename = self.generic_restore_test_genzip(
-            model_list, full_serialization)
-        self.generic_restore_test(zip_filename, current_number,
-                                  model_list)
+            model_list, full_serialization
+        )
+        self.generic_restore_test(zip_filename, current_number, model_list)
 
     def test_export_action(self):
         self.full_create()
-        model_list = get_type_models() + CONF_MODEL_LIST + IMPORT_MODEL_LIST + \
-             GEO_MODEL_LIST + DIRECTORY_MODEL_LIST + OPERATION_MODEL_LIST + \
-             CR_MODEL_LIST + FIND_MODEL_LIST + WAREHOUSE_MODEL_LIST
+        model_list = (
+            get_type_models()
+            + CONF_MODEL_LIST
+            + IMPORT_MODEL_LIST
+            + GEO_MODEL_LIST
+            + DIRECTORY_MODEL_LIST
+            + OPERATION_MODEL_LIST
+            + CR_MODEL_LIST
+            + FIND_MODEL_LIST
+            + WAREHOUSE_MODEL_LIST
+        )
         task = models.ExportTask.objects.create(state="S")
         launch_export(task.pk)
         task = models.ExportTask.objects.get(pk=task.pk)
         current_number = {}
         for model in model_list:
-            current_number[(model.__module__, model.__name__)] = \
-                model.objects.count()
-        self.generic_restore_test(task.result.path, current_number,
-                                  model_list)
+            current_number[(model.__module__, model.__name__)] = model.objects.count()
+        self.generic_restore_test(task.result.path, current_number, model_list)
 
         task = models.ExportTask.objects.create(
-            filter_type="O", filter_text="66666", state="S")
+            filter_type="O", filter_text="66666", state="S"
+        )
         current_number.update(
             {
                 ("archaeological_operations.models", "ArchaeologicalSite"): 1,
@@ -1195,39 +1242,38 @@ class SerializationTest(GenericSerializationTest, TestCase):
         )
         launch_export(task.pk)
         task = models.ExportTask.objects.get(pk=task.pk)
-        self.generic_restore_test(task.result.path, current_number,
-                                  model_list)
+        self.generic_restore_test(task.result.path, current_number, model_list)
 
 
 class AccessControlTest(TestCase):
     def test_administrator(self):
         admin, created = models.PersonType.objects.get_or_create(
-            txt_idx='administrator', defaults={'label': 'Admin'})
-        user, created = User.objects.get_or_create(username='myusername')
+            txt_idx="administrator", defaults={"label": "Admin"}
+        )
+        user, created = User.objects.get_or_create(username="myusername")
         user.is_superuser = True
         user.save()
-        ishtar_user = models.IshtarUser.objects.get(
-            user_ptr__username='myusername')
+        ishtar_user = models.IshtarUser.objects.get(user_ptr__username="myusername")
         self.assertEqual(
-              models.UserProfile.objects.filter(
-                  person__ishtaruser=ishtar_user,
-                  profile_type__txt_idx='administrator'
-              ).count(), 1
+            models.UserProfile.objects.filter(
+                person__ishtaruser=ishtar_user, profile_type__txt_idx="administrator"
+            ).count(),
+            1,
         )
         user = ishtar_user.user_ptr
         user.is_superuser = False
         user.save()
         self.assertEqual(
             models.UserProfile.objects.filter(
-                person__ishtaruser=ishtar_user,
-                profile_type__txt_idx='administrator'
-            ).count(), 1
+                person__ishtaruser=ishtar_user, profile_type__txt_idx="administrator"
+            ).count(),
+            1,
         )  # no more automatic deletion of profile for admin
         self.assertEqual(
             models.UserProfile.objects.filter(
-                person__ishtaruser=ishtar_user,
-                profile_type__txt_idx='administrator'
-            ).count(), 1
+                person__ishtaruser=ishtar_user, profile_type__txt_idx="administrator"
+            ).count(),
+            1,
         )
 
     def test_django_admin(self):
@@ -1243,7 +1289,7 @@ class AccessControlTest(TestCase):
         response = client.get(url)
         self.assertRedirects(response, "/admin/login/?next={}".format(url))
 
-        User.objects.filter(username='myusername').update(is_staff=True)
+        User.objects.filter(username="myusername").update(is_staff=True)
         client.logout()
         client.login(username=username, password=password)
         response = client.get(url)
@@ -1253,8 +1299,7 @@ class AccessControlTest(TestCase):
         response = client.get(url)
         self.assertEqual(response.status_code, 403)
 
-        user.user_permissions.add(Permission.objects.get(
-            codename='change_persontype'))
+        user.user_permissions.add(Permission.objects.get(codename="change_persontype"))
         client.logout()
         client.login(username=username, password=password)
         response = client.get(url)
@@ -1265,76 +1310,84 @@ class UserProfileTest(TestCase):
     fixtures = OPERATION_FIXTURES
 
     def setUp(self):
-        self.password = 'mypassword'
+        self.password = "mypassword"
         self.username = "myuser"
         self.user = User.objects.create_superuser(
-            self.username, 'myemail@test.com', self.password)
+            self.username, "myemail@test.com", self.password
+        )
         self.user.set_password(self.password)
         self.user.save()
         self.client = Client()
         self.client.login(username=self.username, password=self.password)
 
     def test_profile_edit(self):
-        base_url = '/profile/'
+        base_url = "/profile/"
         base_profile = self.user.ishtaruser.current_profile
         response = self.client.get(base_url)
         self.assertEqual(response.status_code, 200)
         response = self.client.post(
-            base_url, {'name': "New name", "current_profile": base_profile.pk})
+            base_url, {"name": "New name", "current_profile": base_profile.pk}
+        )
         self.assertEqual(response.status_code, 302)
         base_profile = models.UserProfile.objects.get(pk=base_profile.pk)
-        self.assertEqual(
-            base_profile.name,
-            "New name"
-        )
+        self.assertEqual(base_profile.name, "New name")
 
         self.client.post(
-            base_url, {'delete_profile': True, 'name': "New name",
-                       "current_profile": base_profile.pk})
+            base_url,
+            {
+                "delete_profile": True,
+                "name": "New name",
+                "current_profile": base_profile.pk,
+            },
+        )
         self.assertEqual(response.status_code, 302)
         # cannot delete a profile it is the last of his kind
-        self.assertEqual(
-            self.user.ishtaruser.person.profiles.count(),
-            1
-        )
+        self.assertEqual(self.user.ishtaruser.person.profiles.count(), 1)
 
         self.client.post(
-            base_url, {'name': "New name", 'duplicate_profile': True,
-                       "current_profile": base_profile.pk})
+            base_url,
+            {
+                "name": "New name",
+                "duplicate_profile": True,
+                "current_profile": base_profile.pk,
+            },
+        )
         self.assertEqual(response.status_code, 302)
         # duplicate
-        self.assertEqual(
-            self.user.ishtaruser.person.profiles.count(),
-            2
-        )
+        self.assertEqual(self.user.ishtaruser.person.profiles.count(), 2)
         # new current profile is the duplicated
         new_profile = self.user.ishtaruser.current_profile
         base_profile = models.UserProfile.objects.get(pk=base_profile.pk)
-        self.assertNotEqual(base_profile.pk,
-                            new_profile.pk)
-        self.assertNotEqual(base_profile.name,
-                            new_profile.name)
+        self.assertNotEqual(base_profile.pk, new_profile.pk)
+        self.assertNotEqual(base_profile.name, new_profile.name)
 
         response = self.client.post(
-            base_url, {'name': "New name", "current_profile": new_profile.pk})
+            base_url, {"name": "New name", "current_profile": new_profile.pk}
+        )
         self.assertIn(
-            b"errorlist nonfield", response.content,
-            msg="An error should be isplayed as this name is already taken"
+            b"errorlist nonfield",
+            response.content,
+            msg="An error should be isplayed as this name is already taken",
         )
 
         # the deletion can now occurs
         self.client.post(
-            base_url, {'delete_profile': True,
-                       "current_profile": base_profile.pk})
-        self.assertEqual(
-            self.user.ishtaruser.person.profiles.count(),
-            1
+            base_url, {"delete_profile": True, "current_profile": base_profile.pk}
         )
+        self.assertEqual(self.user.ishtaruser.person.profiles.count(), 1)
 
 
 class AcItem:
-    def __init__(self, model, url, lbl_key=None, prepare_func=None,
-                 id_key="pk", one_word_search=False, default_values=None):
+    def __init__(
+        self,
+        model,
+        url,
+        lbl_key=None,
+        prepare_func=None,
+        id_key="pk",
+        one_word_search=False,
+        default_values=None,
+    ):
         self.model, self.url, self.lbl_key = model, url, lbl_key
         self.prepare_func, self.id_key = prepare_func, id_key
         self.one_word_search = one_word_search
@@ -1345,10 +1398,11 @@ class AcItem:
 
 class AutocompleteTestBase:
     def setUp(self):
-        self.password = 'mypassword'
+        self.password = "mypassword"
         self.username = "myuser"
         user = User.objects.create_superuser(
-            self.username, 'myemail@test.com', self.password)
+            self.username, "myemail@test.com", self.password
+        )
         user.set_password(self.password)
         user.save()
         self.user = user
@@ -1373,57 +1427,75 @@ class AutocompleteTestBase:
                 item, __ = model.objects.get_or_create(**create_dict)
             response = self.client.get(url, {"term": search_term})
             self.assertEqual(
-                response.status_code, 200,
-                msg="Status code != 200 - {}".format(url))
+                response.status_code, 200, msg="Status code != 200 - {}".format(url)
+            )
             data = json.loads(response.content.decode())
             self.assertEqual(
-                len(data), 1,
+                len(data),
+                1,
                 msg="{} result for '{}' expected 1 - {}".format(
-                    len(data), search_term, url))
+                    len(data), search_term, url
+                ),
+            )
             self.assertEqual(
-                data[0]['id'], getattr(item, mdl.id_key),
+                data[0]["id"],
+                getattr(item, mdl.id_key),
                 msg="id: {} expected {} for '{}' - {}".format(
-                    data[0]['id'], item.pk, search_term, url))
+                    data[0]["id"], item.pk, search_term, url
+                ),
+            )
 
             if mdl.one_word_search:
                 continue
             search_term = "ler " + search_term
             response = self.client.get(url, {"term": search_term})
             self.assertEqual(
-                response.status_code, 200,
-                msg="Status code != 200 when reaching {}".format(url))
+                response.status_code,
+                200,
+                msg="Status code != 200 when reaching {}".format(url),
+            )
             data = json.loads(response.content.decode())
             self.assertEqual(
-                len(data), 1,
+                len(data),
+                1,
                 msg="{} result for '{}' expected 1 - {}".format(
-                    len(data), search_term, url))
+                    len(data), search_term, url
+                ),
+            )
             self.assertEqual(
-                data[0]['id'], getattr(item, mdl.id_key),
+                data[0]["id"],
+                getattr(item, mdl.id_key),
                 msg="id: {} expected {} for '{}' - {}".format(
-                    data[0]['id'], item.pk, search_term, url))
+                    data[0]["id"], item.pk, search_term, url
+                ),
+            )
 
 
 class AutocompleteTest(AutocompleteTestBase, TestCase):
     fixtures = OPERATION_FIXTURES
     models = [
-        AcItem(models.User, 'autocomplete-user', "username"),
-        AcItem(models.User, 'autocomplete-ishtaruser', "username"),
-        AcItem(models.Person, 'autocomplete-person', "name"),
-        AcItem(models.Person, 'autocomplete-person-permissive', "name"),
-        AcItem(models.Town, 'autocomplete-town', "name"),
-        AcItem(models.Town, 'autocomplete-advanced-town',
-               prepare_func="create_advanced_town"),
+        AcItem(models.User, "autocomplete-user", "username"),
+        AcItem(models.User, "autocomplete-ishtaruser", "username"),
+        AcItem(models.Person, "autocomplete-person", "name"),
+        AcItem(models.Person, "autocomplete-person-permissive", "name"),
+        AcItem(models.Town, "autocomplete-town", "name"),
+        AcItem(
+            models.Town,
+            "autocomplete-advanced-town",
+            prepare_func="create_advanced_town",
+        ),
         AcItem(models.Department, "autocomplete-department", "label"),
-        AcItem(models.Author, "autocomplete-author",
-               prepare_func="create_author"),
-        AcItem(models.Organization, 'autocomplete-organization',
-               prepare_func="create_orga"),
+        AcItem(models.Author, "autocomplete-author", prepare_func="create_author"),
+        AcItem(
+            models.Organization, "autocomplete-organization", prepare_func="create_orga"
+        ),
     ]
 
     def create_advanced_town(self, base_name):
         town, __ = models.Town.objects.get_or_create(name=base_name)
-        dep, __ = models.Department.objects.get_or_create(label="Mydepartment",
-                                                          number=999)
+        dep, __ = models.Department.objects.get_or_create(
+            label="Mydepartment", number=999
+        )
         town.departement = dep
         town.save()
         return town, "Mydepart"
@@ -1431,40 +1503,53 @@ class AutocompleteTest(AutocompleteTestBase, TestCase):
     def create_author(self, base_name):
         person, __ = models.Person.objects.get_or_create(name=base_name)
         author, __ = models.Author.objects.get_or_create(
-            person=person, author_type=models.AuthorType.objects.all()[0])
+            person=person, author_type=models.AuthorType.objects.all()[0]
+        )
         return author, None
 
     def create_orga(self, base_name):
         orga, __ = models.Organization.objects.get_or_create(
-            name=base_name,
-            organization_type=models.OrganizationType.objects.all()[0])
+            name=base_name, organization_type=models.OrganizationType.objects.all()[0]
+        )
         return orga, None
 
 
 class AdminGenTypeTest(TestCase):
     fixtures = OPERATION_FIXTURES
     gen_models = [
-        models.OrganizationType, models.PersonType, models.TitleType,
-        models.AuthorType, models.SourceType, models.OperationType,
-        models.SpatialReferenceSystem, models.Format, models.SupportType,
+        models.OrganizationType,
+        models.PersonType,
+        models.TitleType,
+        models.AuthorType,
+        models.SourceType,
+        models.OperationType,
+        models.SpatialReferenceSystem,
+        models.Format,
+        models.SupportType,
     ]
     models_with_data = gen_models + [models.ImporterModel]
     models = models_with_data
-    module_name = 'ishtar_common'
+    module_name = "ishtar_common"
     ishtar_apps = [
-        'ishtar_common', 'archaeological_files', 'archaeological_operations',
-        'archaeological_context_records', 'archaeological_warehouse',
-        'archaeological_finds'
+        "ishtar_common",
+        "archaeological_files",
+        "archaeological_operations",
+        "archaeological_context_records",
+        "archaeological_warehouse",
+        "archaeological_finds",
+    ]
+    readonly_models = [
+        "archaeological_finds.Property",
+        "archaeological_finds.Treatment",
+        "ishtar_common.ProfileTypeSummary",
     ]
-    readonly_models = ['archaeological_finds.Property',
-                       'archaeological_finds.Treatment',
-                       'ishtar_common.ProfileTypeSummary']
 
     def setUp(self):
-        self.password = 'mypassword'
+        self.password = "mypassword"
         self.username = "myuser"
         user = User.objects.create_superuser(
-            self.username, 'myemail@test.com', self.password)
+            self.username, "myemail@test.com", self.password
+        )
         user.set_password(self.password)
         user.save()
         self.client = Client()
@@ -1479,113 +1564,134 @@ class AdminGenTypeTest(TestCase):
                     models.append((app, model))
         for app, model in models:
             # quick test to verify basic access to listing
-            base_url = '/admin/{}/{}/'.format(app, model.__name__.lower())
+            base_url = "/admin/{}/{}/".format(app, model.__name__.lower())
             url = base_url
             response = self.client.get(url)
             self.assertEqual(
-                response.status_code, 200,
-                msg="Can not access admin list for {}.".format(model))
+                response.status_code,
+                200,
+                msg="Can not access admin list for {}.".format(model),
+            )
             nb = model.objects.count()
             url = base_url + "add/"
             response = self.client.get(url)
             if app + "." + model.__name__ in self.readonly_models:
                 continue
             self.assertEqual(
-                response.status_code, 200,
-                msg="Can not access admin add page for {}.".format(model))
+                response.status_code,
+                200,
+                msg="Can not access admin add page for {}.".format(model),
+            )
             self.assertEqual(
-                nb, model.objects.count(),
+                nb,
+                model.objects.count(),
                 msg="A ghost object have been created on access to add page "
-                    "for {}.".format(model))
+                "for {}.".format(model),
+            )
 
             if nb:
                 url = base_url + "{}/change/".format(model.objects.all()[0].pk)
                 response = self.client.get(url)
                 self.assertEqual(
-                    response.status_code, 200,
-                    msg="Can not access admin detail for {}.".format(model))
+                    response.status_code,
+                    200,
+                    msg="Can not access admin detail for {}.".format(model),
+                )
 
     def test_csv_export(self):
         for model in self.gen_models:
-            url = '/admin/{}/{}/'.format(self.module_name,
-                                         model.__name__.lower())
+            url = "/admin/{}/{}/".format(self.module_name, model.__name__.lower())
             q = model.objects
             if not q.count():
                 continue
             response = self.client.post(
-                url, {'action': 'export_as_csv',
-                      '_selected_action': [str(o.pk) for o in q.all()]})
+                url,
+                {
+                    "action": "export_as_csv",
+                    "_selected_action": [str(o.pk) for o in q.all()],
+                },
+            )
             self.assertEqual(
-                response.status_code, 200,
-                msg="Can not export as CSV for {}.".format(model))
+                response.status_code,
+                200,
+                msg="Can not export as CSV for {}.".format(model),
+            )
             try:
                 f = io.StringIO(response.content.decode())
                 reader = csv.DictReader(f)
                 for row in reader:
-                    if 'txt_idx' in row:
-                        slug_name = 'txt_idx'
-                    elif 'slug' in row:
-                        slug_name = 'slug'
+                    if "txt_idx" in row:
+                        slug_name = "txt_idx"
+                    elif "slug" in row:
+                        slug_name = "slug"
                     else:
                         continue
                     obj = model.objects.get(**{slug_name: row[slug_name]})
                     for k in row:
                         current_value = getattr(obj, k)
                         if not row[k]:
-                            self.assertIn(current_value, [None, ''],
+                            self.assertIn(
+                                current_value,
+                                [None, ""],
                                 msg="Export CSV for {} - {}: CSV value is "
-                                    "null whereas value for object is {}"
-                                    ".".format(model, k, current_value))
+                                "null whereas value for object is {}"
+                                ".".format(model, k, current_value),
+                            )
                             continue
                         field = model._meta.get_field(k)
                         if isinstance(field, BooleanField):
                             if current_value:
                                 self.assertEqual(
-                                    row[k], 'True',
+                                    row[k],
+                                    "True",
                                     msg="Export CSV for {} - {}: CSV value is "
-                                        "{} whereas value for "
-                                        "object is True.".format(model, k,
-                                                                 row[k]))
+                                    "{} whereas value for "
+                                    "object is True.".format(model, k, row[k]),
+                                )
                                 continue
                             else:
                                 self.assertEqual(
-                                    row[k], 'False',
+                                    row[k],
+                                    "False",
                                     msg="Export CSV for {} - {}: CSV value is "
-                                        "{} whereas value for "
-                                        "object is False.".format(
-                                        model, k, row[k]))
+                                    "{} whereas value for "
+                                    "object is False.".format(model, k, row[k]),
+                                )
                                 continue
                         elif isinstance(field, ForeignKey):
                             fmodel = field.rel.to
                             try:
-                                value = fmodel.objects.get(
-                                    **{slug_name: row[k]}
-                                )
+                                value = fmodel.objects.get(**{slug_name: row[k]})
                             except fmodel.DoesNotExist:
-                                msg = "Export CSV for {} - {}: CSV value is "\
-                                      "{} but it is not a vaild slug for {}" \
-                                      ".".format(model, k, row[k], fmodel)
+                                msg = (
+                                    "Export CSV for {} - {}: CSV value is "
+                                    "{} but it is not a vaild slug for {}"
+                                    ".".format(model, k, row[k], fmodel)
+                                )
                                 raise ValidationError(msg)
                             self.assertEqual(
-                                value, current_value,
+                                value,
+                                current_value,
                                 msg="Export CSV for {} - {}: CSV value is "
-                                    "{} whereas value for "
-                                    "object is {}.".format(
-                                    model, k, value, current_value))
+                                "{} whereas value for "
+                                "object is {}.".format(model, k, value, current_value),
+                            )
                         elif type(current_value) == float:
                             self.assertEqual(
-                                float(row[k]), current_value,
+                                float(row[k]),
+                                current_value,
                                 msg="Export CSV for {} - {}: CSV value is "
-                                    "{} whereas value for "
-                                    "object is {}.".format(
-                                    model, k, row[k], current_value))
+                                "{} whereas value for "
+                                "object is {}.".format(model, k, row[k], current_value),
+                            )
                         elif type(current_value) == int:
                             self.assertEqual(
-                                int(row[k]), current_value,
+                                int(row[k]),
+                                current_value,
                                 msg="Export CSV for {} - {}: CSV value is "
-                                    "{} whereas value for "
-                                    "object is {}.".format(
-                                    model, k, row[k], current_value))
+                                "{} whereas value for "
+                                "object is {}.".format(model, k, row[k], current_value),
+                            )
 
             finally:
                 f.close()
@@ -1596,22 +1702,27 @@ class AdminGenTypeTest(TestCase):
             nb = q.count()
             if not nb:
                 continue
-            base_url = '/admin/{}/{}/'.format(self.module_name,
-                                              model.__name__.lower())
+            base_url = "/admin/{}/{}/".format(self.module_name, model.__name__.lower())
             response = self.client.post(
-                base_url, {'action': 'export_as_csv',
-                           '_selected_action': [str(o.pk) for o in q.all()]})
+                base_url,
+                {
+                    "action": "export_as_csv",
+                    "_selected_action": [str(o.pk) for o in q.all()],
+                },
+            )
             self.assertEqual(
-                response.status_code, 200,
-                msg="Can not export as CSV for {}.".format(model))
+                response.status_code,
+                200,
+                msg="Can not export as CSV for {}.".format(model),
+            )
 
             for obj in q.all():
                 obj.delete()
 
-            url = base_url + 'import-from-csv/'
+            url = base_url + "import-from-csv/"
             try:
                 f = io.BytesIO(response.content)
-                response = self.client.post(url, {'csv_file': f, 'apply': True})
+                response = self.client.post(url, {"csv_file": f, "apply": True})
                 self.assertEqual(response.status_code, 302)
                 self.assertRedirects(response, base_url)
                 self.assertEqual(nb, model.objects.count())
@@ -1620,17 +1731,22 @@ class AdminGenTypeTest(TestCase):
 
     def test_json_export(self):
         for model in self.gen_models:
-            url = '/admin/{}/{}/'.format(self.module_name,
-                                         model.__name__.lower())
+            url = "/admin/{}/{}/".format(self.module_name, model.__name__.lower())
             q = model.objects
             if not q.count():
                 continue
             response = self.client.post(
-                url, {'action': '_serialize_action',
-                      '_selected_action': [str(o.pk) for o in q.all()]})
+                url,
+                {
+                    "action": "_serialize_action",
+                    "_selected_action": [str(o.pk) for o in q.all()],
+                },
+            )
             self.assertEqual(
-                response.status_code, 200,
-                msg="Can not export as JSON for {}.".format(model))
+                response.status_code,
+                200,
+                msg="Can not export as JSON for {}.".format(model),
+            )
             # json content already tested on full export
 
     def test_json_import(self):
@@ -1639,23 +1755,27 @@ class AdminGenTypeTest(TestCase):
             nb = q.count()
             if not nb:
                 continue
-            base_url = '/admin/{}/{}/'.format(self.module_name,
-                                              model.__name__.lower())
+            base_url = "/admin/{}/{}/".format(self.module_name, model.__name__.lower())
             response = self.client.post(
-                base_url, {'action': '_serialize_action',
-                           '_selected_action': [str(o.pk) for o in q.all()]})
+                base_url,
+                {
+                    "action": "_serialize_action",
+                    "_selected_action": [str(o.pk) for o in q.all()],
+                },
+            )
             self.assertEqual(
-                response.status_code, 200,
-                msg="Can not export as CSV for {}.".format(model))
+                response.status_code,
+                200,
+                msg="Can not export as CSV for {}.".format(model),
+            )
 
             for obj in q.all():
                 obj.delete()
 
-            url = base_url + 'import-from-json/'
+            url = base_url + "import-from-json/"
             try:
                 f = io.BytesIO(response.content)
-                response = self.client.post(url, {'json_file': f,
-                                                  'apply': True})
+                response = self.client.post(url, {"json_file": f, "apply": True})
                 self.assertEqual(response.status_code, 302)
                 self.assertRedirects(response, base_url)
                 self.assertEqual(nb, model.objects.count())
@@ -1664,71 +1784,67 @@ class AdminGenTypeTest(TestCase):
 
     def test_importer_type_duplicate(self):
         model = models.ImporterType
-        base_url = '/admin/{}/{}/'.format(self.module_name,
-                                          model.__name__.lower())
+        base_url = "/admin/{}/{}/".format(self.module_name, model.__name__.lower())
         ref = model.objects.all()[0]
         nb = model.objects.count()
         response = self.client.post(
-            base_url, {'action': 'duplicate_importertype',
-                       '_selected_action': [str(ref.pk)]})
+            base_url,
+            {"action": "duplicate_importertype", "_selected_action": [str(ref.pk)]},
+        )
         self.assertEqual(response.status_code, 302)
         self.assertEqual(nb + 1, model.objects.count())
-        duplicate = model.objects.order_by('-pk').all()[0]
-        self.assertEqual(duplicate.columns.count(),
-                         ref.columns.count())
+        duplicate = model.objects.order_by("-pk").all()[0]
+        self.assertEqual(duplicate.columns.count(), ref.columns.count())
 
     def test_importer_column_duplicate(self):
         model = models.ImporterColumn
-        base_url = '/admin/{}/{}/'.format(self.module_name,
-                                          model.__name__.lower())
+        base_url = "/admin/{}/{}/".format(self.module_name, model.__name__.lower())
         ref = model.objects.all()[0]
         nb = model.objects.count()
         response = self.client.post(
-            base_url, {'action': 'duplicate_importercolumn',
-                       '_selected_action': [str(ref.pk)]})
+            base_url,
+            {"action": "duplicate_importercolumn", "_selected_action": [str(ref.pk)]},
+        )
         self.assertEqual(response.status_code, 302)
         self.assertEqual(nb + 1, model.objects.count())
-        duplicate = model.objects.order_by('-pk').all()[0]
-        self.assertEqual(duplicate.duplicate_fields.count(),
-                         ref.duplicate_fields.count())
-        self.assertEqual(duplicate.targets.count(),
-                         ref.targets.count())
+        duplicate = model.objects.order_by("-pk").all()[0]
+        self.assertEqual(
+            duplicate.duplicate_fields.count(), ref.duplicate_fields.count()
+        )
+        self.assertEqual(duplicate.targets.count(), ref.targets.count())
 
     def test_importer_column_shift(self):
         model = models.ImporterColumn
-        importer_type = models.ImporterType.objects.get(
-            slug='ishtar-operations')
+        importer_type = models.ImporterType.objects.get(slug="ishtar-operations")
         # col in fixture should be well ordered
-        for idx, col in enumerate(
-                importer_type.columns.order_by('col_number').all()):
+        for idx, col in enumerate(importer_type.columns.order_by("col_number").all()):
             self.assertEqual(col.col_number, idx + 1)
 
-        base_url = '/admin/{}/{}/'.format(self.module_name,
-                                          model.__name__.lower())
+        base_url = "/admin/{}/{}/".format(self.module_name, model.__name__.lower())
         response = self.client.post(
-            base_url, {
-                'action': 'shift_right',
-                '_selected_action': [
-                    str(c.pk) for c in importer_type.columns.all()
-                ]})
+            base_url,
+            {
+                "action": "shift_right",
+                "_selected_action": [str(c.pk) for c in importer_type.columns.all()],
+            },
+        )
         self.assertEqual(response.status_code, 302)
 
         # col shifted to the right
-        for idx, col in enumerate(
-                importer_type.columns.order_by('col_number').all()):
+        for idx, col in enumerate(importer_type.columns.order_by("col_number").all()):
             self.assertEqual(col.col_number, idx + 2)
 
         response = self.client.post(
-            base_url, {
-                'action': 'shift_left',
-                '_selected_action': [
-                    str(c.pk) for c in importer_type.columns.all()
-                ]})
+            base_url,
+            {
+                "action": "shift_left",
+                "_selected_action": [str(c.pk) for c in importer_type.columns.all()],
+            },
+        )
         self.assertEqual(response.status_code, 302)
 
         # col shifted back to the left
-        for idx, col in enumerate(
-                importer_type.columns.order_by('col_number').all()):
+        for idx, col in enumerate(importer_type.columns.order_by("col_number").all()):
             self.assertEqual(col.col_number, idx + 1)
 
     def test_str(self):
@@ -1737,88 +1853,102 @@ class AdminGenTypeTest(TestCase):
             self.assertTrue(str(model.objects.all()[0]))
 
     def test_user_creation(self):
-        url = '/admin/auth/user/add/'
-        password = 'ishtar is the queen'
+        url = "/admin/auth/user/add/"
+        password = "ishtar is the queen"
         response = self.client.post(
-            url, {'username': 'test', 'password1': password,
-                  'password2': password})
+            url, {"username": "test", "password1": password, "password2": password}
+        )
         self.assertEqual(response.status_code, 302)
-        self.assertTrue(self.client.login(username='test', password=password))
+        self.assertTrue(self.client.login(username="test", password=password))
 
 
 class MergeTest(TestCase):
     def setUp(self):
-        self.user, created = User.objects.get_or_create(username='username')
-        self.organisation_types = \
-            models.OrganizationType.create_default_for_test()
+        self.user, created = User.objects.get_or_create(username="username")
+        self.organisation_types = models.OrganizationType.create_default_for_test()
 
-        self.person_types = [models.PersonType.objects.create(label='Admin'),
-                             models.PersonType.objects.create(label='User')]
-        self.author_types = [models.AuthorType.objects.create(label='1'),
-                             models.AuthorType.objects.create(label='2')]
+        self.person_types = [
+            models.PersonType.objects.create(label="Admin"),
+            models.PersonType.objects.create(label="User"),
+        ]
+        self.author_types = [
+            models.AuthorType.objects.create(label="1"),
+            models.AuthorType.objects.create(label="2"),
+        ]
 
         self.company_1 = models.Organization.objects.create(
-            history_modifier=self.user, name='Franquin Comp.',
-            organization_type=self.organisation_types[0])
+            history_modifier=self.user,
+            name="Franquin Comp.",
+            organization_type=self.organisation_types[0],
+        )
         self.person_1 = models.Person.objects.create(
-            name='Boule', surname=' ', history_modifier=self.user,
-            attached_to=self.company_1)
+            name="Boule",
+            surname=" ",
+            history_modifier=self.user,
+            attached_to=self.company_1,
+        )
         self.person_1.person_types.add(self.person_types[0])
 
         self.author_1_pk = models.Author.objects.create(
-            person=self.person_1, author_type=self.author_types[0]).pk
+            person=self.person_1, author_type=self.author_types[0]
+        ).pk
 
-        self.title = models.TitleType.objects.create(label='Test')
+        self.title = models.TitleType.objects.create(label="Test")
 
         self.company_2 = models.Organization.objects.create(
-            history_modifier=self.user, name='Goscinny Corp.',
-            organization_type=self.organisation_types[1])
+            history_modifier=self.user,
+            name="Goscinny Corp.",
+            organization_type=self.organisation_types[1],
+        )
         self.person_2 = models.Person.objects.create(
-            name='Bill', history_modifier=self.user, surname='Peyo',
-            title=self.title, attached_to=self.company_2)
+            name="Bill",
+            history_modifier=self.user,
+            surname="Peyo",
+            title=self.title,
+            attached_to=self.company_2,
+        )
         self.user.ishtaruser.person = self.person_2
         self.user.ishtaruser.save()
         models.UserProfile.objects.create(
-            profile_type=models.ProfileType.objects.all()[0],
-            person=self.person_2
+            profile_type=models.ProfileType.objects.all()[0], person=self.person_2
         )
 
         self.person_2.person_types.add(self.person_types[1])
         self.author_2_pk = models.Author.objects.create(
-            person=self.person_2, author_type=self.author_types[1]).pk
+            person=self.person_2, author_type=self.author_types[1]
+        ).pk
         self.person_3 = models.Person.objects.create(
-            name='George', history_modifier=self.user,
-            attached_to=self.company_1)
+            name="George", history_modifier=self.user, attached_to=self.company_1
+        )
 
     def test_person_merge(self):
         self.person_1.merge(self.person_2)
         # preserve existing fields
-        self.assertEqual(self.person_1.name, 'Boule')
+        self.assertEqual(self.person_1.name, "Boule")
         # fill missing fields
         self.assertEqual(self.person_1.title, self.title)
         # string field with only spaces is an empty field
-        self.assertEqual(self.person_1.surname, 'Peyo')
+        self.assertEqual(self.person_1.surname, "Peyo")
         # preserve one to one field
-        user = User.objects.get(username='username')
+        user = User.objects.get(username="username")
         self.assertEqual(self.person_1, user.ishtaruser.person)
         # preserve existing foreign key
         self.assertEqual(self.person_1.attached_to, self.company_1)
         # preserve existing many to many
-        self.assertTrue(self.person_types[0]
-                        in self.person_1.person_types.all())
+        self.assertTrue(self.person_types[0] in self.person_1.person_types.all())
         # add new many to many
-        self.assertTrue(self.person_types[1]
-                        in self.person_1.person_types.all())
+        self.assertTrue(self.person_types[1] in self.person_1.person_types.all())
         # update reverse foreign key association and do not break the existing
-        self.assertEqual(models.Author.objects.get(pk=self.author_1_pk).person,
-                         self.person_1)
-        self.assertEqual(models.Author.objects.get(pk=self.author_2_pk).person,
-                         self.person_1)
+        self.assertEqual(
+            models.Author.objects.get(pk=self.author_1_pk).person, self.person_1
+        )
+        self.assertEqual(
+            models.Author.objects.get(pk=self.author_2_pk).person, self.person_1
+        )
 
         self.person_3.merge(self.person_1)
         # manage well empty many to many fields
-        self.assertTrue(self.person_types[1]
-                        in self.person_3.person_types.all())
+        self.assertTrue(self.person_types[1] in self.person_3.person_types.all())
 
     def test_person_with_use_account_merge(self):
         # bug: merge when the target is not the one having a Ishtar user account
@@ -1828,23 +1958,25 @@ class MergeTest(TestCase):
         init_mc = self.person_1.merge_candidate.count()
         person = models.Person.objects.create(
             name=self.person_1.name,
-            surname=self.person_1.surname, history_modifier=self.user,
-            attached_to=self.person_1.attached_to)
-        self.assertEqual(self.person_1.merge_candidate.count(),
-                         init_mc + 1)
+            surname=self.person_1.surname,
+            history_modifier=self.user,
+            attached_to=self.person_1.attached_to,
+        )
+        self.assertEqual(self.person_1.merge_candidate.count(), init_mc + 1)
         person.archive()
-        self.assertEqual(self.person_1.merge_candidate.count(),
-                         init_mc)
+        self.assertEqual(self.person_1.merge_candidate.count(), init_mc)
 
 
 class ShortMenuTest(TestCase):
     def setUp(self):
-        self.username = 'username666'
-        self.password = 'dcbqj7xnjkxnjsknx!@%'
+        self.username = "username666"
+        self.password = "dcbqj7xnjkxnjsknx!@%"
         self.user = User.objects.create_superuser(
-            self.username, "nomail@nomail.com", self.password)
+            self.username, "nomail@nomail.com", self.password
+        )
         self.other_user = User.objects.create_superuser(
-            'John', "nomail@nomail.com", self.password)
+            "John", "nomail@nomail.com", self.password
+        )
         profile = models.get_current_profile()
         profile.files = True
         profile.context_record = True
@@ -1856,6 +1988,7 @@ class ShortMenuTest(TestCase):
         if not user:
             user = self.other_user
         from archaeological_operations.models import Operation, OperationType
+
         ope_type, created = OperationType.objects.get_or_create(label="test")
         idx = 1
         while Operation.objects.filter(code_patriarche=str(idx)).count():
@@ -1863,23 +1996,24 @@ class ShortMenuTest(TestCase):
         return Operation.objects.create(
             operation_type=ope_type,
             history_modifier=user,
-            year=2042, operation_code=54,
-            code_patriarche=str(idx)
+            year=2042,
+            operation_code=54,
+            code_patriarche=str(idx),
         )
 
     def test_not_connected(self):
         c = Client()
-        response = c.get(reverse('shortcut-menu'))
+        response = c.get(reverse("shortcut-menu"))
         # no content if not logged
         self.assertFalse(b"shortcut-menu" in response.content)
         c = Client()
         c.login(username=self.username, password=self.password)
         # no content because the user owns no object
-        response = c.get(reverse('shortcut-menu'))
+        response = c.get(reverse("shortcut-menu"))
         self.assertFalse(b"shortcut-menu" in response.content)
         self._create_ope(user=self.user)
         # content is here
-        response = c.get(reverse('shortcut-menu'))
+        response = c.get(reverse("shortcut-menu"))
         self.assertTrue(b"shortcut-menu" in response.content)
 
     def test_operation(self):
@@ -1887,14 +2021,14 @@ class ShortMenuTest(TestCase):
         c.login(username=self.username, password=self.password)
         ope = self._create_ope()
         # not available at first
-        response = c.get(reverse('shortcut-menu'))
+        response = c.get(reverse("shortcut-menu"))
         self.assertEqual(response.status_code, 200)
         self.assertFalse(str(ope.cached_label) in response.content.decode())
 
         # available because is the creator
         ope.history_creator = self.user
         ope.save()
-        response = c.get(reverse('shortcut-menu'))
+        response = c.get(reverse("shortcut-menu"))
         self.assertEqual(response.status_code, 200)
         self.assertTrue(str(ope.cached_label) in response.content.decode())
 
@@ -1902,7 +2036,7 @@ class ShortMenuTest(TestCase):
         ope.history_creator = self.other_user
         ope.in_charge = self.user.ishtaruser.person
         ope.save()
-        response = c.get(reverse('shortcut-menu'))
+        response = c.get(reverse("shortcut-menu"))
         self.assertEqual(response.status_code, 200)
         self.assertTrue(str(ope.cached_label) in response.content.decode())
 
@@ -1911,14 +2045,14 @@ class ShortMenuTest(TestCase):
         ope.in_charge = None
         ope.scientist = self.user.ishtaruser.person
         ope.save()
-        response = c.get(reverse('shortcut-menu'))
+        response = c.get(reverse("shortcut-menu"))
         self.assertEqual(response.status_code, 200)
         self.assertTrue(str(ope.cached_label) in response.content.decode())
 
         # end date is reached - no more available
         ope.end_date = datetime.date(1900, 1, 1)
         ope.save()
-        response = c.get(reverse('shortcut-menu'))
+        response = c.get(reverse("shortcut-menu"))
         self.assertEqual(response.status_code, 200)
         self.assertFalse(str(ope.cached_label) in response.content.decode())
 
@@ -1931,12 +2065,13 @@ class ShortMenuTest(TestCase):
         session = c.session
         session[ope.SLUG] = ope.pk
         session.save()
-        response = c.get(reverse('shortcut-menu'))
+        response = c.get(reverse("shortcut-menu"))
         self.assertEqual(response.status_code, 200)
         self.assertTrue(str(ope.cached_label) in response.content.decode())
 
     def testFile(self):
         from archaeological_files.models import File, FileType
+
         c = Client()
         c.login(username=self.username, password=self.password)
         file_type = FileType.objects.create()
@@ -1946,14 +2081,14 @@ class ShortMenuTest(TestCase):
             year=2043,
         )
         # not available at first
-        response = c.get(reverse('shortcut-menu'))
+        response = c.get(reverse("shortcut-menu"))
         self.assertEqual(response.status_code, 200)
         self.assertFalse(str(fle.cached_label) in response.content.decode())
 
         # available because is the creator
         fle.history_creator = self.user
         fle.save()
-        response = c.get(reverse('shortcut-menu'))
+        response = c.get(reverse("shortcut-menu"))
         self.assertEqual(response.status_code, 200)
         self.assertTrue(str(fle.cached_label) in response.content.decode())
 
@@ -1961,27 +2096,25 @@ class ShortMenuTest(TestCase):
         fle.history_creator = self.other_user
         fle.in_charge = self.user.ishtaruser.person
         fle.save()
-        response = c.get(reverse('shortcut-menu'))
+        response = c.get(reverse("shortcut-menu"))
         self.assertEqual(response.status_code, 200)
         self.assertTrue(str(fle.cached_label) in response.content.decode())
 
         # end date is reached - no more available
         fle.end_date = datetime.date(1900, 1, 1)
         fle.save()
-        response = c.get(reverse('shortcut-menu'))
+        response = c.get(reverse("shortcut-menu"))
         self.assertEqual(response.status_code, 200)
         self.assertFalse(str(fle.cached_label) in response.content.decode())
 
     def _create_cr(self):
         from archaeological_context_records.models import ContextRecord
         from archaeological_operations.models import Parcel
+
         ope = self._create_ope()
         town = models.Town.objects.create()
         parcel = Parcel.objects.create(
-            operation=ope,
-            town=town,
-            section="AA",
-            parcel_number=42
+            operation=ope, town=town, section="AA", parcel_number=42
         )
         return ContextRecord.objects.create(
             parcel=parcel,
@@ -1995,14 +2128,14 @@ class ShortMenuTest(TestCase):
         cr = self._create_cr()
 
         # not available at first
-        response = c.get(reverse('shortcut-menu'))
+        response = c.get(reverse("shortcut-menu"))
         self.assertEqual(response.status_code, 200)
         self.assertFalse(str(cr.cached_label) in response.content.decode())
 
         # available because is the creator
         cr.history_creator = self.user
         cr.save()
-        response = c.get(reverse('shortcut-menu'))
+        response = c.get(reverse("shortcut-menu"))
         self.assertEqual(response.status_code, 200)
         self.assertTrue(str(cr.cached_label) in response.content.decode())
 
@@ -2011,7 +2144,7 @@ class ShortMenuTest(TestCase):
         cr.save()
         cr.operation.in_charge = self.user.ishtaruser.person
         cr.operation.save()
-        response = c.get(reverse('shortcut-menu'))
+        response = c.get(reverse("shortcut-menu"))
         self.assertEqual(response.status_code, 200)
         self.assertTrue(str(cr.cached_label) in response.content.decode())
 
@@ -2021,19 +2154,16 @@ class ShortMenuTest(TestCase):
         cr.operation.in_charge = None
         cr.operation.scientist = self.user.ishtaruser.person
         cr.save()
-        response = c.get(reverse('shortcut-menu'))
+        response = c.get(reverse("shortcut-menu"))
         self.assertEqual(response.status_code, 200)
         self.assertTrue(str(cr.cached_label) in response.content.decode())
 
     def _create_find(self):
         from archaeological_finds.models import BaseFind, Find
+
         cr = self._create_cr()
-        base_find = BaseFind.objects.create(
-            context_record=cr
-        )
-        find = Find.objects.create(
-            label="Where is my find?"
-        )
+        base_find = BaseFind.objects.create(context_record=cr)
+        find = Find.objects.create(label="Where is my find?")
         find.base_finds.add(base_find)
         return base_find, find
 
@@ -2043,24 +2173,23 @@ class ShortMenuTest(TestCase):
         base_find, find = self._create_find()
 
         # not available at first
-        response = c.get(reverse('shortcut-menu'))
+        response = c.get(reverse("shortcut-menu"))
         self.assertEqual(response.status_code, 200)
         self.assertFalse(str(find.cached_label) in response.content.decode())
 
         # available because is the creator
         find.history_creator = self.user
         find.save()
-        response = c.get(reverse('shortcut-menu'))
+        response = c.get(reverse("shortcut-menu"))
         self.assertEqual(response.status_code, 200)
         self.assertTrue(str(find.cached_label) in response.content.decode())
 
         # available because is in charge
         find.history_creator = self.other_user
         find.save()
-        base_find.context_record.operation.in_charge = \
-            self.user.ishtaruser.person
+        base_find.context_record.operation.in_charge = self.user.ishtaruser.person
         base_find.context_record.operation.save()
-        response = c.get(reverse('shortcut-menu'))
+        response = c.get(reverse("shortcut-menu"))
         self.assertEqual(response.status_code, 200)
         self.assertTrue(str(find.cached_label) in response.content.decode())
 
@@ -2068,10 +2197,9 @@ class ShortMenuTest(TestCase):
         find.history_creator = self.other_user
         find.save()
         base_find.context_record.operation.in_charge = None
-        base_find.context_record.operation.scientist = \
-            self.user.ishtaruser.person
+        base_find.context_record.operation.scientist = self.user.ishtaruser.person
         base_find.context_record.operation.save()
-        response = c.get(reverse('shortcut-menu'))
+        response = c.get(reverse("shortcut-menu"))
         self.assertEqual(response.status_code, 200)
         self.assertTrue(str(find.cached_label) in response.content.decode())
 
@@ -2079,34 +2207,34 @@ class ShortMenuTest(TestCase):
         c = Client()
         c.login(username=self.username, password=self.password)
         from archaeological_finds.models import FindBasket
+
         basket = FindBasket.objects.create(
             label="My basket",
         )
 
         # not available at first
-        response = c.get(reverse('shortcut-menu'))
+        response = c.get(reverse("shortcut-menu"))
         self.assertEqual(response.status_code, 200)
         self.assertFalse(str(basket.label) in response.content.decode())
 
         # available because is the owner
         basket.user = self.user.ishtaruser
         basket.save()
-        response = c.get(reverse('shortcut-menu'))
+        response = c.get(reverse("shortcut-menu"))
         self.assertEqual(response.status_code, 200)
         self.assertTrue(str(basket.label) in response.content.decode())
 
     def test_treatment_file(self):
         c = Client()
         c.login(username=self.username, password=self.password)
-        from archaeological_finds.models import TreatmentFile, \
-            TreatmentFileType
+        from archaeological_finds.models import TreatmentFile, TreatmentFileType
+
         tf = TreatmentFile.objects.create(
-            type=TreatmentFileType.objects.create(),
-            year=2050
+            type=TreatmentFileType.objects.create(), year=2050
         )
 
         # not available at first
-        response = c.get(reverse('shortcut-menu'))
+        response = c.get(reverse("shortcut-menu"))
         self.assertEqual(response.status_code, 200)
         self.assertFalse(str(tf.cached_label) in response.content.decode())
 
@@ -2114,7 +2242,7 @@ class ShortMenuTest(TestCase):
         tf.history_creator = self.user
         tf.save()
         tf = TreatmentFile.objects.get(pk=tf.pk)
-        response = c.get(reverse('shortcut-menu'))
+        response = c.get(reverse("shortcut-menu"))
         self.assertEqual(response.status_code, 200)
         self.assertTrue(str(tf.cached_label) in response.content.decode())
 
@@ -2122,26 +2250,25 @@ class ShortMenuTest(TestCase):
         tf.history_creator = self.other_user
         tf.in_charge = self.user.ishtaruser.person
         tf.save()
-        response = c.get(reverse('shortcut-menu'))
+        response = c.get(reverse("shortcut-menu"))
         self.assertEqual(response.status_code, 200)
         self.assertTrue(str(tf.cached_label) in response.content.decode())
 
         # end date is reached - no more available
         tf.end_date = datetime.date(1900, 1, 1)
         tf.save()
-        response = c.get(reverse('shortcut-menu'))
+        response = c.get(reverse("shortcut-menu"))
         self.assertEqual(response.status_code, 200)
         self.assertFalse(str(tf.cached_label) in response.content.decode())
 
     def _create_treatment(self):
         from archaeological_finds.models import Treatment, TreatmentState
+
         completed, created = TreatmentState.objects.get_or_create(
-            txt_idx='completed', defaults={"executed": True, "label": "Done"}
+            txt_idx="completed", defaults={"executed": True, "label": "Done"}
         )
         return Treatment.objects.create(
-            label="My treatment",
-            year=2052,
-            treatment_state=completed
+            label="My treatment", year=2052, treatment_state=completed
         )
 
     def test_treatment(self):
@@ -2150,14 +2277,14 @@ class ShortMenuTest(TestCase):
         treat = self._create_treatment()
 
         # not available at first
-        response = c.get(reverse('shortcut-menu'))
+        response = c.get(reverse("shortcut-menu"))
         self.assertEqual(response.status_code, 200)
         self.assertFalse(str(treat.cached_label) in response.content.decode())
 
         # available because is the creator
         treat.history_creator = self.user
         treat.save()
-        response = c.get(reverse('shortcut-menu'))
+        response = c.get(reverse("shortcut-menu"))
         self.assertEqual(response.status_code, 200)
         self.assertTrue(str(treat.cached_label) in response.content.decode())
 
@@ -2165,14 +2292,14 @@ class ShortMenuTest(TestCase):
         treat.history_creator = self.other_user
         treat.person = self.user.ishtaruser.person
         treat.save()
-        response = c.get(reverse('shortcut-menu'))
+        response = c.get(reverse("shortcut-menu"))
         self.assertEqual(response.status_code, 200)
         self.assertTrue(str(treat.cached_label) in response.content.decode())
 
         # end date is reached - no more available
         treat.end_date = datetime.date(1900, 1, 1)
         treat.save()
-        response = c.get(reverse('shortcut-menu'))
+        response = c.get(reverse("shortcut-menu"))
         self.assertEqual(response.status_code, 200)
         self.assertFalse(str(treat.cached_label) in response.content.decode())
 
@@ -2182,55 +2309,52 @@ class ShortMenuTest(TestCase):
         base_find, find = self._create_find()
 
         response = c.post(
-            reverse('pin-search', args=['find']),
-            {'value': 'Where is my find'},
-            **{'HTTP_X_REQUESTED_WITH': 'XMLHttpRequest'}
+            reverse("pin-search", args=["find"]),
+            {"value": "Where is my find"},
+            **{"HTTP_X_REQUESTED_WITH": "XMLHttpRequest"}
         )
         self.assertEqual(response.status_code, 200)
         # the selected find search is pined
-        self.assertEqual(c.session['pin-search-find'], 'Where is my find')
+        self.assertEqual(c.session["pin-search-find"], "Where is my find")
 
         # empty search save means empty dependant search
-        c.get(
-            reverse('pin', args=['contextrecord',
-                                 str(base_find.context_record.pk)])
-        )
+        c.get(reverse("pin", args=["contextrecord", str(base_find.context_record.pk)]))
         response = c.post(
-            reverse('pin-search', args=['find']),
-            {'value': ''},
-            **{'HTTP_X_REQUESTED_WITH': 'XMLHttpRequest'}
+            reverse("pin-search", args=["find"]),
+            {"value": ""},
+            **{"HTTP_X_REQUESTED_WITH": "XMLHttpRequest"}
         )
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(c.session['pin-search-find'], '')
-        self.assertEqual(c.session['contextrecord'], '')
+        self.assertEqual(c.session["pin-search-find"], "")
+        self.assertEqual(c.session["contextrecord"], "")
 
     def test_update_current_item(self):
         c = Client()
         c.login(username=self.username, password=self.password)
         base_find, find = self._create_find()
 
-        response = c.get(reverse('pin', args=['find', find.pk]))
+        response = c.get(reverse("pin", args=["find", find.pk]))
         self.assertEqual(response.status_code, 200)
         # the selected find is pined
-        self.assertEqual(c.session['find'], str(find.pk))
+        self.assertEqual(c.session["find"], str(find.pk))
         # dependant items are also pined
-        self.assertEqual(c.session['contextrecord'],
-                         str(base_find.context_record.pk))
-        self.assertEqual(c.session['operation'],
-                         str(base_find.context_record.operation.pk))
+        self.assertEqual(c.session["contextrecord"], str(base_find.context_record.pk))
+        self.assertEqual(
+            c.session["operation"], str(base_find.context_record.operation.pk)
+        )
 
         # pin another operation - dependant items are nullify
         ope = self._create_ope()
-        response = c.get(reverse('pin', args=['operation', ope.pk]))
+        response = c.get(reverse("pin", args=["operation", ope.pk]))
         self.assertEqual(response.status_code, 200)
-        self.assertFalse(c.session['find'])
-        self.assertFalse(c.session['contextrecord'])
+        self.assertFalse(c.session["find"])
+        self.assertFalse(c.session["contextrecord"])
 
         # current find is set as an integer
         session = c.session
-        session['find'] = find.id
+        session["find"] = find.id
         session.save()
-        response = c.get(reverse('shortcut-menu'))
+        response = c.get(reverse("shortcut-menu"))
         self.assertEqual(response.status_code, 200)
 
         self._create_treatment()
@@ -2239,16 +2363,14 @@ class ShortMenuTest(TestCase):
         c = Client()
         c.login(username=self.username, password=self.password)
         from archaeological_finds.models import FindBasket
-        basket = FindBasket.objects.create(
-            label="My basket",
-            user=self.user.ishtaruser
-        )
+
+        basket = FindBasket.objects.create(label="My basket", user=self.user.ishtaruser)
         session = c.session
-        session['find'] = 'basket-{}'.format(basket.pk)
+        session["find"] = "basket-{}".format(basket.pk)
         session.save()
-        response = c.get(reverse('shortcut-menu'))
+        response = c.get(reverse("shortcut-menu"))
         self.assertEqual(response.status_code, 200)
-        response = c.get(reverse('get-document'))
+        response = c.get(reverse("get-document"))
         self.assertEqual(response.status_code, 200)
 
 
@@ -2256,22 +2378,23 @@ class ImportTest(TestCase):
     def create_import(self):
         create_user()
         imp_model = models.ImporterModel.objects.create(
-            klass='ishtar_common.models.Person', name='Person')
-        importer_type = models.ImporterType.objects.create(
-            associated_models=imp_model)
+            klass="ishtar_common.models.Person", name="Person"
+        )
+        importer_type = models.ImporterType.objects.create(associated_models=imp_model)
 
         dest = os.path.join(settings.MEDIA_ROOT, "MCC-operations-example.csv")
         shutil.copy(
-            settings.ROOT_PATH +
-            '../archaeological_operations/tests/MCC-operations-example.csv',
-            dest
+            settings.ROOT_PATH
+            + "../archaeological_operations/tests/MCC-operations-example.csv",
+            dest,
         )
-        with open(dest, 'rb') as f:
+        with open(dest, "rb") as f:
             mcc_operation_file = DjangoFile(f)
             imprt = models.Import.objects.create(
                 user=models.IshtarUser.objects.all()[0],
                 importer_type=importer_type,
-                imported_file=mcc_operation_file)
+                imported_file=mcc_operation_file,
+            )
         return imprt
 
     def test_archive_import(self):
@@ -2279,8 +2402,7 @@ class ImportTest(TestCase):
         with open(imprt.imported_file.path, "r") as f:
             csv_content = f.read()
         with tempfile.TemporaryDirectory() as tmpdir:
-            for k in ("error_file", "result_file", "match_file",
-                      "imported_images"):
+            for k in ("error_file", "result_file", "match_file", "imported_images"):
                 sample_file = os.path.join(tmpdir, "media_{}.zip".format(k))
                 with open(sample_file, "w") as m:
                     m.write("test" + k)
@@ -2299,7 +2421,7 @@ class ImportTest(TestCase):
         self.assertTrue(imprt.archive_file)
         self.assertTrue(zipfile.is_zipfile(imprt.archive_file))
         with tempfile.TemporaryDirectory() as tmpdir:
-            current_zip = zipfile.ZipFile(imprt.archive_file.path, 'r')
+            current_zip = zipfile.ZipFile(imprt.archive_file.path, "r")
             name_list = current_zip.namelist()
             self.assertIn("content.json", name_list)
             current_zip.extract("content.json", tmpdir)
@@ -2324,7 +2446,7 @@ class ImportTest(TestCase):
                     with open(os.path.join(tmpdir, name), "r") as f:
                         self.assertEqual(f.read(), csv_content)
 
-        imprt.unarchive('FE')
+        imprt.unarchive("FE")
         imprt = models.Import.objects.get(pk=imprt.pk)
         self.assertEqual(imprt.state, "FE")
         for k in ("error_file", "result_file", "match_file", "imported_images"):
@@ -2353,43 +2475,53 @@ class ImportTest(TestCase):
         self.assertFalse(imprt.imported_images)
 
     def test_delete_related(self):
-        town = models.Town.objects.create(name='my-test')
-        self.assertEqual(models.Town.objects.filter(name='my-test').count(), 1)
+        town = models.Town.objects.create(name="my-test")
+        self.assertEqual(models.Town.objects.filter(name="my-test").count(), 1)
 
         imprt = self.create_import()
 
         town.imports.add(imprt)
         imprt.delete()
         # town should be deleted
-        self.assertEqual(models.Town.objects.filter(name='my-test').count(),
-                         0)
+        self.assertEqual(models.Town.objects.filter(name="my-test").count(), 0)
 
     def test_keys(self):
-        content_type = ContentType.objects.get_for_model(
-            models.OrganizationType)
+        content_type = ContentType.objects.get_for_model(models.OrganizationType)
 
         # creation
         label = "Ploufé"
         ot = models.OrganizationType.objects.create(label=label)
-        self.assertEqual(models.ItemKey.objects.filter(
-                         object_id=ot.pk, key=slugify(label),
-                         content_type=content_type).count(), 1)
+        self.assertEqual(
+            models.ItemKey.objects.filter(
+                object_id=ot.pk, key=slugify(label), content_type=content_type
+            ).count(),
+            1,
+        )
         label_2 = "Plif"
         ot_2 = models.OrganizationType.objects.create(label=label_2)
-        self.assertEqual(models.ItemKey.objects.filter(
-                         object_id=ot_2.pk, key=slugify(label_2),
-                         content_type=content_type).count(), 1)
+        self.assertEqual(
+            models.ItemKey.objects.filter(
+                object_id=ot_2.pk, key=slugify(label_2), content_type=content_type
+            ).count(),
+            1,
+        )
 
         # replace key
         ot_2.add_key(slugify(label), force=True)
         # one key point to only one item
-        self.assertEqual(models.ItemKey.objects.filter(
-                         key=slugify(label),
-                         content_type=content_type).count(), 1)
+        self.assertEqual(
+            models.ItemKey.objects.filter(
+                key=slugify(label), content_type=content_type
+            ).count(),
+            1,
+        )
         # this key point to the right item
-        self.assertEqual(models.ItemKey.objects.filter(
-                         object_id=ot_2.pk, key=slugify(label),
-                         content_type=content_type).count(), 1)
+        self.assertEqual(
+            models.ItemKey.objects.filter(
+                object_id=ot_2.pk, key=slugify(label), content_type=content_type
+            ).count(),
+            1,
+        )
 
         # modification
         label_3 = "Yop"
@@ -2397,32 +2529,43 @@ class ImportTest(TestCase):
         ot_2.txt_idx = slugify(label_3)
         ot_2.save()
         # old label not referenced anymore
-        self.assertEqual(models.ItemKey.objects.filter(
-                         object_id=ot_2.pk, key=slugify(label_2),
-                         content_type=content_type).count(), 0)
+        self.assertEqual(
+            models.ItemKey.objects.filter(
+                object_id=ot_2.pk, key=slugify(label_2), content_type=content_type
+            ).count(),
+            0,
+        )
         # # forced key association is always here
         # new key is here
-        self.assertEqual(models.ItemKey.objects.filter(
-                         object_id=ot_2.pk, key=slugify(label),
-                         content_type=content_type).count(), 1)
-        self.assertEqual(models.ItemKey.objects.filter(
-                         object_id=ot_2.pk, key=slugify(label_3),
-                         content_type=content_type).count(), 1)
+        self.assertEqual(
+            models.ItemKey.objects.filter(
+                object_id=ot_2.pk, key=slugify(label), content_type=content_type
+            ).count(),
+            1,
+        )
+        self.assertEqual(
+            models.ItemKey.objects.filter(
+                object_id=ot_2.pk, key=slugify(label_3), content_type=content_type
+            ).count(),
+            1,
+        )
 
 
 class IshtarSiteProfileTest(TestCase):
-    fixtures = [settings.ROOT_PATH +
-                '../fixtures/initial_data-auth-fr.json',
-                settings.ROOT_PATH +
-                '../ishtar_common/fixtures/initial_data-fr.json',]
+    fixtures = [
+        settings.ROOT_PATH + "../fixtures/initial_data-auth-fr.json",
+        settings.ROOT_PATH + "../ishtar_common/fixtures/initial_data-fr.json",
+    ]
 
     def testRelevance(self):
-        cache.set('default-ishtarsiteprofile-is-current-profile', None,
-                  settings.CACHE_TIMEOUT)
+        cache.set(
+            "default-ishtarsiteprofile-is-current-profile", None, settings.CACHE_TIMEOUT
+        )
         profile = models.get_current_profile()
         default_slug = profile.slug
         profile2 = models.IshtarSiteProfile.objects.create(
-            label="Test profile 2", slug='test-profile-2')
+            label="Test profile 2", slug="test-profile-2"
+        )
         profile2.save()
         # when no profile is the current, activate by default the first created
         self.assertTrue(profile.active and not profile2.active)
@@ -2443,52 +2586,53 @@ class IshtarSiteProfileTest(TestCase):
         self.assertTrue(profile2.context_record and profile2.find)
 
     def testDefaultProfile(self):
-        cache.set('default-ishtar_common-IshtarSiteProfile', None,
-                  settings.CACHE_TIMEOUT)
+        cache.set(
+            "default-ishtar_common-IshtarSiteProfile", None, settings.CACHE_TIMEOUT
+        )
         self.assertFalse(models.IshtarSiteProfile.objects.count())
         profile = models.get_current_profile(force=True)
         self.assertTrue(profile)
         self.assertEqual(models.IshtarSiteProfile.objects.count(), 1)
 
     def test_menu_filtering(self):
-        cache.set('default-ishtarsiteprofile-is-current-profile', None,
-                  settings.CACHE_TIMEOUT)
-        username = 'username4277'
-        password = 'dcbqj756456!@%'
-        User.objects.create_superuser(username, "nomail@nomail.com",
-                                      password)
+        cache.set(
+            "default-ishtarsiteprofile-is-current-profile", None, settings.CACHE_TIMEOUT
+        )
+        username = "username4277"
+        password = "dcbqj756456!@%"
+        User.objects.create_superuser(username, "nomail@nomail.com", password)
         c = Client()
         c.login(username=username, password=password)
-        response = c.get(reverse('start'))
+        response = c.get(reverse("start"))
         self.assertNotIn(b'href="/file_search/"', response.content)
         profile = models.get_current_profile()
         profile.files = True
         profile.save()
-        response = c.get(reverse('start'))
+        response = c.get(reverse("start"))
         self.assertIn(b'href="/file_search/"', response.content)
 
     def testExternalKey(self):
         profile = models.get_current_profile()
-        p = models.Person.objects.create(name='plouf', surname='Tégada')
+        p = models.Person.objects.create(name="plouf", surname="Tégada")
         self.assertEqual(p.raw_name, "PLOUF Tégada")
-        profile.person_raw_name = '{surname|slug} {name}'
+        profile.person_raw_name = "{surname|slug} {name}"
         profile.save()
-        p.raw_name = ''
+        p.raw_name = ""
         p.save()
         self.assertEqual(p.raw_name, "tegada plouf")
 
 
 class IshtarBasicTest(TestCase):
     def setUp(self):
-        self.password = 'mypassword'
+        self.password = "mypassword"
         self.my_admin = User.objects.create_superuser(
-            'myuser', 'myemail@test.com', self.password)
+            "myuser", "myemail@test.com", self.password
+        )
         self.client = Client()
-        self.client.login(username=self.my_admin.username,
-                          password=self.password)
+        self.client.login(username=self.my_admin.username, password=self.password)
 
     def test_status(self):
-        response = self.client.get(reverse('status'))
+        response = self.client.get(reverse("status"))
         self.assertEqual(response.status_code, 200)
 
     def test_person_rawname(self):
@@ -2501,28 +2645,29 @@ class IshtarBasicTest(TestCase):
     def test_show(self):
         person = models.Person.objects.create(name="Weasley", surname="Bill")
         orga_type = models.OrganizationType.objects.create(
-            txt_idx='test', label='testy')
+            txt_idx="test", label="testy"
+        )
         company = models.Organization.objects.create(
-            history_modifier=self.my_admin, name='Franquin Comp.',
-            organization_type=orga_type)
+            history_modifier=self.my_admin,
+            name="Franquin Comp.",
+            organization_type=orga_type,
+        )
         c = Client()
 
-        response = c.get(reverse('show-person', kwargs={'pk': person.pk}))
+        response = c.get(reverse("show-person", kwargs={"pk": person.pk}))
         self.assertEqual(response.status_code, 200)
         # empty content when not allowed
         self.assertEqual(response.content, b"")
-        response = c.get(reverse('show-organization',
-                                 kwargs={'pk': company.pk}))
+        response = c.get(reverse("show-organization", kwargs={"pk": company.pk}))
         self.assertEqual(response.status_code, 200)
         # empty content when not allowed
         self.assertEqual(response.content, b"")
 
         c.login(username=self.my_admin.username, password=self.password)
-        response = c.get(reverse('show-person', kwargs={'pk': person.pk}))
+        response = c.get(reverse("show-person", kwargs={"pk": person.pk}))
         self.assertEqual(response.status_code, 200)
         self.assertIn(b'class="card sheet"', response.content)
-        response = c.get(reverse('show-organization',
-                                 kwargs={'pk': company.pk}))
+        response = c.get(reverse("show-organization", kwargs={"pk": company.pk}))
         self.assertEqual(response.status_code, 200)
         self.assertIn(b'class="card sheet"', response.content)
 
@@ -2535,8 +2680,7 @@ class IshtarBasicTest(TestCase):
         town = models.Town.objects.get(numero_insee="99999")
         self.assertEqual(town.cached_label, "Sin City - 99")
 
-        models.Town.objects.create(name="Mega City", numero_insee="99999",
-                                   year=2051)
+        models.Town.objects.create(name="Mega City", numero_insee="99999", year=2051)
         mega_city = models.Town.objects.get(numero_insee="99999", year=2051)
         town.children.add(mega_city)
         town = models.Town.objects.get(numero_insee="99999-2050")
@@ -2548,13 +2692,14 @@ class GeomaticTest(TestCase):
         class FakeGeomaticObject(object):
             _meta = models.GeoItem._meta
 
-            def __init__(self, x, y, z, spatial_reference_system, point=None,
-                         point_2d=None):
+            def __init__(
+                self, x, y, z, spatial_reference_system, point=None, point_2d=None
+            ):
                 self.x = x
                 self.y = y
                 self.z = z
                 self.spatial_reference_system = spatial_reference_system
-                self.point_source = 'P'
+                self.point_source = "P"
                 self.point_source_item = ""
                 self.point = point
                 self.point_2d = point_2d
@@ -2562,16 +2707,15 @@ class GeomaticTest(TestCase):
 
             def save(self, *args, **kwargs):
                 pass
+
         profile = models.get_current_profile()
         profile.mapping = True
         profile.save()
 
         srs = models.SpatialReferenceSystem.objects.create(
-            label='WGS84', txt_idx='wgs84', srid=4326
+            label="WGS84", txt_idx="wgs84", srid=4326
         )
-        obj = FakeGeomaticObject(
-            x=2, y=3, z=4,
-            spatial_reference_system=srs)
+        obj = FakeGeomaticObject(x=2, y=3, z=4, spatial_reference_system=srs)
         self.assertIsNone(obj.point_2d)
         post_save_geo(FakeGeomaticObject, instance=obj)
         self.assertIsNotNone(obj.point_2d)
@@ -2585,10 +2729,8 @@ class NewItems(TestCase):
         self.username, self.password, self.user = create_superuser()
 
     def test_new_author(self):
-        url = 'new-author'
-        person = models.Person.objects.create(
-            name="Hop", surname="Oups"
-        )
+        url = "new-author"
+        person = models.Person.objects.create(name="Hop", surname="Oups")
 
         c = Client()
         # TODO
@@ -2600,30 +2742,29 @@ class NewItems(TestCase):
 
         response = c.post(
             reverse(url),
-            {"person": person.id,
-             "author_type": models.AuthorType.objects.all()[0].pk}
+            {"person": person.id, "author_type": models.AuthorType.objects.all()[0].pk},
         )
         self.assertEqual(response.status_code, 200)
         self.assertEqual(person.author.count(), 1)
 
 
 class AccountWizardTest(WizardTest, TestCase):
-    fixtures = [settings.ROOT_PATH +
-                '../fixtures/initial_data-auth-fr.json',
-                settings.ROOT_PATH +
-                '../ishtar_common/fixtures/initial_data-fr.json',]
-    url_name = 'account_management'
-    wizard_name = 'account_wizard'
+    fixtures = [
+        settings.ROOT_PATH + "../fixtures/initial_data-auth-fr.json",
+        settings.ROOT_PATH + "../ishtar_common/fixtures/initial_data-fr.json",
+    ]
+    url_name = "account_management"
+    wizard_name = "account_wizard"
     steps = views.account_wizard_steps
     form_datas = [
         WizardTestFormData(
             "Add an account",
             form_datas={
-                'account': {
-                    'username': "My username",
-                    'email': "test@example.com",
-                    'hidden_password': "my_pass",
-                    'hidden_password_confirm': "my_pass",
+                "account": {
+                    "username": "My username",
+                    "email": "test@example.com",
+                    "hidden_password": "my_pass",
+                    "hidden_password_confirm": "my_pass",
                 }
             },
         ),
@@ -2631,10 +2772,11 @@ class AccountWizardTest(WizardTest, TestCase):
 
     def pre_wizard(self):
         self.person = models.Person.objects.create(
-            name='Boule', surname=' ',
+            name="Boule",
+            surname=" ",
         )
-        self.form_datas[0].set('selec', 'pk', self.person.pk)
-        self.form_datas[0].set('account', 'pk', self.person.pk)
+        self.form_datas[0].set("selec", "pk", self.person.pk)
+        self.form_datas[0].set("account", "pk", self.person.pk)
 
         self.account_number = models.IshtarUser.objects.count()
         super(AccountWizardTest, self).pre_wizard()
@@ -2644,15 +2786,15 @@ class AccountWizardTest(WizardTest, TestCase):
         user = person.ishtaruser.user_ptr
         self.assertEqual(user.username, "My username")
         self.assertEqual(user.email, "test@example.com")
-        self.assertEqual(models.IshtarUser.objects.count(),
-                         self.account_number + 1)
+        self.assertEqual(models.IshtarUser.objects.count(), self.account_number + 1)
 
 
 class DashboardTest(TestCase):
     def setUp(self):
         self.username, self.password, self.user = create_superuser()
         profile, created = models.IshtarSiteProfile.objects.get_or_create(
-            slug='default', active=True)
+            slug="default", active=True
+        )
         profile.files = True
         profile.context_record = True
         profile.find = True
@@ -2663,33 +2805,46 @@ class DashboardTest(TestCase):
         c = Client()
         c.login(username=self.username, password=self.password)
 
-        url = 'dashboard-main-detail'
-
-        response = c.get(reverse(url, kwargs={'item_name': "zorglub"}))
-        self.assertEqual(
-            response.status_code, 404)
-
-        for item in ['users', 'files', 'treatmentfiles', 'treatments',
-                     'operations', 'contextrecords', 'finds']:
-            response = c.get(reverse(url, kwargs={'item_name': item}))
+        url = "dashboard-main-detail"
+
+        response = c.get(reverse(url, kwargs={"item_name": "zorglub"}))
+        self.assertEqual(response.status_code, 404)
+
+        for item in [
+            "users",
+            "files",
+            "treatmentfiles",
+            "treatments",
+            "operations",
+            "contextrecords",
+            "finds",
+        ]:
+            response = c.get(reverse(url, kwargs={"item_name": item}))
             self.assertEqual(
-                response.status_code, 200,
-                "Reaching dashboard for item: {} return an error.".format(url))
+                response.status_code,
+                200,
+                "Reaching dashboard for item: {} return an error.".format(url),
+            )
 
 
 class CleanMedia(TestCase):
     def test_rename(self):
         test_names = [
-            ("éofficier2-12-02-04.93_gvK3hAr-1_2m7zZPn-1_nKhh2S2-1_"\
-             "ONmUhfD-1_ymA3gGJ-1_XzJyRx3-1_PhvRcO8-1-thumb_ZwWMKBd.jpg",
-             "éofficier2-12-02-04.93-thumb.jpg"),
+            (
+                "éofficier2-12-02-04.93_gvK3hAr-1_2m7zZPn-1_nKhh2S2-1_"
+                "ONmUhfD-1_ymA3gGJ-1_XzJyRx3-1_PhvRcO8-1-thumb_ZwWMKBd.jpg",
+                "éofficier2-12-02-04.93-thumb.jpg",
+            ),
             ("a_ZwWMKBd.jpg", False),  # no rename because too short
-            ("hoplala_gvK3hAr_2m7zZPn_nKhh2S2_ZwWMKBd.jpg",
-             "hoplala_gvK3hAr_2m7zZPn_nKhh2S2.jpg",),  # stop before because
+            (
+                "hoplala_gvK3hAr_2m7zZPn_nKhh2S2_ZwWMKBd.jpg",
+                "hoplala_gvK3hAr_2m7zZPn_nKhh2S2.jpg",
+            ),  # stop before because
             # another file exists
         ]
-        base_dir = os.sep.join([settings.ROOT_PATH, "..", "ishtar_common",
-                                "tests", "rename"])
+        base_dir = os.sep.join(
+            [settings.ROOT_PATH, "..", "ishtar_common", "tests", "rename"]
+        )
         for name, expected in test_names:
             name = os.sep.join([base_dir, name])
             new_name, modif = rename_and_simplify_media_name(name, rename=False)
@@ -2701,12 +2856,15 @@ class CleanMedia(TestCase):
 
     def test_try_fix(self):
         test_names = [
-            ("hoplala_gvK3hAr_2m7zZPn_nKhh2S2_ZwWMKBd_ZwWMKBd.jpg",
-             # non existing file
-             "hoplala_gvK3hAr_2m7zZPn.jpg",),
+            (
+                "hoplala_gvK3hAr_2m7zZPn_nKhh2S2_ZwWMKBd_ZwWMKBd.jpg",
+                # non existing file
+                "hoplala_gvK3hAr_2m7zZPn.jpg",
+            ),
         ]
-        base_dir = os.sep.join([settings.ROOT_PATH, "..", "ishtar_common",
-                                "tests", "rename"])
+        base_dir = os.sep.join(
+            [settings.ROOT_PATH, "..", "ishtar_common", "tests", "rename"]
+        )
         for name, expected in test_names:
             name = os.sep.join([base_dir, name])
 
@@ -2719,8 +2877,7 @@ class PersonQATest(TestCase):
 
     def setUp(self):
         self.username, self.password, self.user = create_superuser()
-        self.user.user_permissions.add(Permission.objects.get(
-            codename='change_person'))
+        self.user.user_permissions.add(Permission.objects.get(codename="change_person"))
         self.title_1 = models.TitleType.objects.create(label="T1", txt_idx="t1")
         self.title_2 = models.TitleType.objects.create(label="T2", txt_idx="t2")
         self.person_1 = models.Person.objects.create(title=self.title_1)
@@ -2729,51 +2886,52 @@ class PersonQATest(TestCase):
     def test_bulk_update(self):
         c = Client()
         pks = "{}-{}".format(self.person_1.pk, self.person_2.pk)
-        response = c.get(reverse('person-qa-bulk-update', args=[pks]))
-        self.assertRedirects(response, '/')
+        response = c.get(reverse("person-qa-bulk-update", args=[pks]))
+        self.assertRedirects(response, "/")
 
         c = Client()
         c.login(username=self.username, password=self.password)
-        response = c.get(reverse('person-qa-bulk-update', args=[pks]))
+        response = c.get(reverse("person-qa-bulk-update", args=[pks]))
         self.assertEqual(response.status_code, 200)
 
         self.assertNotEqual(self.person_1.title, self.title_2)
         self.assertNotEqual(self.person_2.title, self.title_2)
 
         response = c.post(
-            reverse('person-qa-bulk-update-confirm', args=[pks]),
-            {'qa_title': self.title_2.pk}
+            reverse("person-qa-bulk-update-confirm", args=[pks]),
+            {"qa_title": self.title_2.pk},
         )
         if response.status_code != 200:
-            self.assertRedirects(response, '/success/')
+            self.assertRedirects(response, "/success/")
         self.assertEqual(
-            models.Person.objects.get(pk=self.person_1.pk).title,
-            self.title_2
+            models.Person.objects.get(pk=self.person_1.pk).title, self.title_2
         )
         self.assertEqual(
-            models.Person.objects.get(pk=self.person_2.pk).title,
-            self.title_2
+            models.Person.objects.get(pk=self.person_2.pk).title, self.title_2
         )
 
 
 class DocumentTest(TestCase):
     def setUp(self):
         Operation = apps.get_model("archaeological_operations", "Operation")
-        ContextRecord = apps.get_model("archaeological_context_records",
-                                       "ContextRecord")
+        ContextRecord = apps.get_model(
+            "archaeological_context_records", "ContextRecord"
+        )
         Unit = apps.get_model("archaeological_context_records", "Unit")
         BaseFind = apps.get_model("archaeological_finds", "BaseFind")
         Find = apps.get_model("archaeological_finds", "Find")
         operation_type, __ = models.OperationType.objects.get_or_create(
-            txt_idx="arch_diagnostic", label="Diagnostic")
+            txt_idx="arch_diagnostic", label="Diagnostic"
+        )
         self.ope1 = Operation.objects.create(
-            code_patriarche="001",
-            operation_type_id=operation_type.pk)
+            code_patriarche="001", operation_type_id=operation_type.pk
+        )
         self.ope2 = Operation.objects.create(
-            code_patriarche="002",
-            operation_type_id=operation_type.pk)
+            code_patriarche="002", operation_type_id=operation_type.pk
+        )
         su, __ = Unit.objects.get_or_create(
-            txt_idx='stratigraphic-unit', label="Stratigraphic unit", order=1)
+            txt_idx="stratigraphic-unit", label="Stratigraphic unit", order=1
+        )
         self.cr1 = ContextRecord.objects.create(operation=self.ope1, unit=su)
         self.cr2 = ContextRecord.objects.create(operation=self.ope2, unit=su)
         bf1 = BaseFind.objects.create(context_record=self.cr1)
@@ -2783,31 +2941,35 @@ class DocumentTest(TestCase):
         self.find2 = Find.objects.create()
         self.find2.base_finds.add(bf2)
         self.st1 = models.SourceType.objects.create(label="Report", code="REP")
-        self.st2 = models.SourceType.objects.create(label="Illustration",
-                                                    code="ILL")
+        self.st2 = models.SourceType.objects.create(label="Illustration", code="ILL")
 
     def test_custom_index(self):
         profile, created = models.IshtarSiteProfile.objects.get_or_create(
-            slug='default', active=True)
-        profile.document_complete_identifier = \
+            slug="default", active=True
+        )
+        profile.document_complete_identifier = (
             "{operation_codes}-{source_type__code}-{custom_index}"
+        )
         profile.document_custom_index = "operation"
         profile.save()
 
-        doc = models.Document.objects.create(source_type=self.st1,
-                                             title="Operation report")
+        doc = models.Document.objects.create(
+            source_type=self.st1, title="Operation report"
+        )
         doc.operations.add(self.ope1)
         doc = models.Document.objects.get(pk=doc.pk)
         self.assertEqual(doc.complete_identifier, "001-REP-1")
 
-        doc2 = models.Document.objects.create(source_type=self.st2,
-                                              title="Illustration CR")
+        doc2 = models.Document.objects.create(
+            source_type=self.st2, title="Illustration CR"
+        )
         doc2.context_records.add(self.cr1)
         doc2 = models.Document.objects.get(pk=doc2.pk)
         self.assertEqual(doc2.complete_identifier, "001-ILL-2")
 
-        doc3 = models.Document.objects.create(source_type=self.st1,
-                                              title="Operation report 2")
+        doc3 = models.Document.objects.create(
+            source_type=self.st1, title="Operation report 2"
+        )
         doc3.operations.add(self.ope2)
         doc3 = models.Document.objects.get(pk=doc3.pk)
         self.assertEqual(doc3.complete_identifier, "002-REP-1")
@@ -2817,12 +2979,13 @@ class DocumentTest(TestCase):
         doc3.save()
         doc3 = models.Document.objects.get(pk=doc3.pk)
         self.assertEqual(doc3.custom_index, None)  # 2 operations - no index
-        self.assertEqual(doc3.complete_identifier, '001|002-REP-')
+        self.assertEqual(doc3.complete_identifier, "001|002-REP-")
 
         # complex jinja identifier
-        profile.document_complete_identifier = \
-            "{% if custom_index %}{{operation_codes}}-{{source_type__code}}-" \
-            "{{ \"%03d\" % (custom_index|int)}}{% else %}no-code{% endif %}"
+        profile.document_complete_identifier = (
+            "{% if custom_index %}{{operation_codes}}-{{source_type__code}}-"
+            '{{ "%03d" % (custom_index|int)}}{% else %}no-code{% endif %}'
+        )
         profile.save()
 
         doc3.operations.remove(self.ope1)
@@ -2830,18 +2993,19 @@ class DocumentTest(TestCase):
         doc3.complete_identifier = ""
         doc3.save()
         doc3 = models.Document.objects.get(pk=doc3.pk)
-        self.assertEqual(doc3.complete_identifier, '002-REP-001')
+        self.assertEqual(doc3.complete_identifier, "002-REP-001")
 
         doc3.operations.remove(self.ope2)
         doc3.custom_index = None
         doc3.complete_identifier = ""
         doc3.save()
         doc3 = models.Document.objects.get(pk=doc3.pk)
-        self.assertEqual(doc3.complete_identifier, 'no-code')
+        self.assertEqual(doc3.complete_identifier, "no-code")
 
     def test_clean_duplicate_association(self):
-        doc = models.Document.objects.create(source_type=self.st1,
-                                             title="Operation report")
+        doc = models.Document.objects.create(
+            source_type=self.st1, title="Operation report"
+        )
         doc.operations.add(self.ope1)
         doc.context_records.add(self.cr1)
         doc = models.Document.objects.get(pk=doc.pk)
@@ -2882,33 +3046,35 @@ class JinjaFilterTest(TestCase):
         self.assertEqual(utils_secretary.splitpart("1,2,3", 10), "")
         self.assertEqual(utils_secretary.splitpart("", 10), "")
         self.assertEqual(utils_secretary.splitpart("1;2;3", 2, ";"), "3")
-        self.assertEqual(utils_secretary.splitpart(
-            "1;2;3;4", 1, ";", True), "2;3;4")
+        self.assertEqual(utils_secretary.splitpart("1;2;3;4", 1, ";", True), "2;3;4")
 
     def test_human_date(self):
         self.assertEqual(utils_secretary.human_date_filter("NODATE"), "")
         self.assertEqual(
-            utils_secretary.human_date_filter("2020-01-01"),
-            "1 janvier 2020")
+            utils_secretary.human_date_filter("2020-01-01"), "1 janvier 2020"
+        )
 
     def test_capfirst(self):
         self.assertEqual(
             utils_secretary.capfirst_filter("saint georges d'oléron"),
-            "Saint georges d'oléron")
+            "Saint georges d'oléron",
+        )
         self.assertEqual(utils_secretary.capfirst_filter("s"), "S")
         self.assertEqual(utils_secretary.capfirst_filter(""), "")
 
     def test_capitalize(self):
         self.assertEqual(
             utils_secretary.capitalize_filter("SAINT-GEORGES D'OLÉRON"),
-            "Saint-Georges d'Oléron")
+            "Saint-Georges d'Oléron",
+        )
         self.assertEqual(utils_secretary.capitalize_filter("s"), "S")
         self.assertEqual(utils_secretary.capitalize_filter(""), "")
 
     def test_lowerfirst(self):
         self.assertEqual(
             utils_secretary.lowerfirst_filter("SAINT GEORGES D'OLÉRON"),
-            "sAINT GEORGES D'OLÉRON")
+            "sAINT GEORGES D'OLÉRON",
+        )
         self.assertEqual(utils_secretary.lowerfirst_filter("S"), "s")
         self.assertEqual(utils_secretary.lowerfirst_filter(""), "")
 
@@ -2916,49 +3082,45 @@ class JinjaFilterTest(TestCase):
 class TemplateGenerationTest(TestCase):
     def test_filters(self):
         model, __ = models.ImporterModel.objects.get_or_create(
-            klass='archaeological_finds.models.Find'
+            klass="archaeological_finds.models.Find"
         )
         q = models.DocumentTemplate.objects.filter(slug="test")
         if q.count():
             q.all()[0].delete()
         doc = models.DocumentTemplate.objects.create(
-            name="Test",
-            slug="test",
-            associated_model=model,
-            available=True)
+            name="Test", slug="test", associated_model=model, available=True
+        )
 
         LABEL_EXPECTED_KEYS = [
-            'container_index',
-            'context_record_operation_common_name',
-            'context_record_town_name',
-            'container_location_name',
-            'context_record_operation_operation_type',
-            'container_reference',
-            'my_complete_id',
-            'complete_idx',
-            'complete_idxy',
+            "container_index",
+            "context_record_operation_common_name",
+            "context_record_town_name",
+            "container_location_name",
+            "context_record_operation_operation_type",
+            "container_reference",
+            "my_complete_id",
+            "complete_idx",
+            "complete_idxy",
         ]
-        tpl_label = settings.ROOT_PATH + \
-            '../ishtar_common/tests/test-filters-label.odt'
+        tpl_label = settings.ROOT_PATH + "../ishtar_common/tests/test-filters-label.odt"
         BASE_EXPECTED_KEYS = [
-            'container_index',
-            'context_record_operation_common_name',
-            'context_record_town_name',
-            'container_location_name',
-            'context_record_operation_operation_type',
-            'container_reference',
-            'my_complete_id',
-            'complete_idx',
-            'complete_idxy',
+            "container_index",
+            "context_record_operation_common_name",
+            "context_record_town_name",
+            "container_location_name",
+            "context_record_operation_operation_type",
+            "container_reference",
+            "my_complete_id",
+            "complete_idx",
+            "complete_idxy",
         ]
-        tpl_base = settings.ROOT_PATH + \
-              '../ishtar_common/tests/test-filters-base.odt'
+        tpl_base = settings.ROOT_PATH + "../ishtar_common/tests/test-filters-base.odt"
         tests = (
             (LABEL_EXPECTED_KEYS, tpl_label, models.DocumentTemplate.LABEL_RE),
             (BASE_EXPECTED_KEYS, tpl_base, models.DocumentTemplate.BASE_RE),
         )
         for expected_keys, tpl, filter_re in tests:
-            with open(tpl, 'rb') as tpl:
+            with open(tpl, "rb") as tpl:
                 template = SimpleUploadedFile("template.odt", tpl.read())
                 filtr = doc.get_filter(template, filter_re)
                 for key in expected_keys: