Format - black: finds

1 files changed, 911 insertions, 822 deletions

diff --git a/archaeological_finds/tests.py b/archaeological_finds/tests.py
index 61caca858..bb249e2ea 100644
--- a/archaeological_finds/tests.py
+++ b/archaeological_finds/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>
 
@@ -35,27 +35,63 @@ from django.core.files.uploadedfile import SimpleUploadedFile
 from django.core.urlresolvers import reverse
 from django.test import tag
 from django.test.client import Client
-from ishtar_common.models import ImporterType, IshtarUser, ImporterColumn,\
-    FormaterType, ImportTarget, IshtarSiteProfile, ProfileType, ImporterModel, \
-    DocumentTemplate
+from ishtar_common.models import (
+    ImporterType,
+    IshtarUser,
+    ImporterColumn,
+    FormaterType,
+    ImportTarget,
+    IshtarSiteProfile,
+    ProfileType,
+    ImporterModel,
+    DocumentTemplate,
+)
 from django.utils.text import slugify
 from django.utils.translation import pgettext_lazy, gettext_lazy as _
 
-from ishtar_common.models import Person, get_current_profile, UserProfile, \
-    Town, Area, Document, SpatialReferenceSystem
-from archaeological_context_records.models import Period, Dating, \
-    ContextRecord, DatingType, DatingQuality
+from ishtar_common.models import (
+    Person,
+    get_current_profile,
+    UserProfile,
+    Town,
+    Area,
+    Document,
+    SpatialReferenceSystem,
+)
+from archaeological_context_records.models import (
+    Period,
+    Dating,
+    ContextRecord,
+    DatingType,
+    DatingQuality,
+)
 from archaeological_finds import models, views
-from archaeological_warehouse.models import Warehouse, WarehouseType, \
-    ContainerType, Container, WarehouseDivisionLink
+from archaeological_warehouse.models import (
+    Warehouse,
+    WarehouseType,
+    ContainerType,
+    Container,
+    WarehouseDivisionLink,
+)
 from archaeological_operations.models import Operation, OperationType
 
 from ishtar_common import forms_common
 
-from ishtar_common.tests import WizardTest, WizardTestFormData as FormData, \
-    TestCase, create_user, create_superuser, AutocompleteTestBase, AcItem, \
-    FIND_FIXTURES, FIND_TOWNS_FIXTURES, WAREHOUSE_FIXTURES, \
-    COMMON_FIXTURES, GenericSerializationTest, SearchText
+from ishtar_common.tests import (
+    WizardTest,
+    WizardTestFormData as FormData,
+    TestCase,
+    create_user,
+    create_superuser,
+    AutocompleteTestBase,
+    AcItem,
+    FIND_FIXTURES,
+    FIND_TOWNS_FIXTURES,
+    WAREHOUSE_FIXTURES,
+    COMMON_FIXTURES,
+    GenericSerializationTest,
+    SearchText,
+)
 from archaeological_operations.tests import ImportTest, create_operation
 from archaeological_context_records.tests import ContextRecordInit
 
@@ -72,22 +108,25 @@ class FindInit(ContextRecordInit):
             data_base = {}
         if not data:
             data = {}
-        if not getattr(self, 'finds', None):
+        if not getattr(self, "finds", None):
             self.finds = []
-        if not getattr(self, 'base_finds', None):
+        if not getattr(self, "base_finds", None):
             self.base_finds = []
 
-        default = {'label': "Base find"}
+        default = {"label": "Base find"}
         if user:
-            data_base['history_modifier'] = user
-        elif not data_base.get('history_modifier') or not data_base[
-            'history_modifier'].pk:
+            data_base["history_modifier"] = user
+        elif (
+            not data_base.get("history_modifier")
+            or not data_base["history_modifier"].pk
+        ):
             user = self.get_default_user()
             user.save()
-            data_base['history_modifier'] = user
-        if force or not data_base.get('context_record'):
-            data_base['context_record'] = self.get_default_context_record(
-                force=force, user=user)
+            data_base["history_modifier"] = user
+        if force or not data_base.get("context_record"):
+            data_base["context_record"] = self.get_default_context_record(
+                force=force, user=user
+            )
         default.update(data_base)
         base_find = models.BaseFind.objects.create(**default)
         self.base_finds.append(base_find)
@@ -106,14 +145,14 @@ class FindInit(ContextRecordInit):
 
     def tearDown(self):
         super(FindInit, self).tearDown()
-        if hasattr(self, 'finds'):
+        if hasattr(self, "finds"):
             for f in self.finds:
                 try:
                     f.delete()
                 except:
                     pass
             self.finds = []
-        if hasattr(self, 'base_finds'):
+        if hasattr(self, "base_finds"):
             for f in self.base_finds:
                 try:
                     f.delete()
@@ -128,12 +167,8 @@ class SerializationTest(GenericSerializationTest, FindInit, TestCase):
     def setUp(self):
         ope1 = self.create_operation()[0]
         ope2 = self.create_operation()[1]
-        cr = self.create_context_record(
-            data={"label": "CR 1", "operation": ope1}
-        )[0]
-        cr2 = self.create_context_record(
-            data={"label": "CR 2", "operation": ope2}
-        )[1]
+        cr = self.create_context_record(data={"label": "CR 1", "operation": ope1})[0]
+        cr2 = self.create_context_record(data={"label": "CR 2", "operation": ope2})[1]
         self.create_finds(data_base={"context_record": cr})[0]
         self.create_finds(data_base={"context_record": cr2})[1]
         # basket = models.FindBasket.objects.create(label="Hophop")
@@ -142,164 +177,145 @@ class SerializationTest(GenericSerializationTest, FindInit, TestCase):
 
     def test_serialization(self):
         res = self.generic_serialization_test(serializers.find_serialization)
-        find_json = json.loads(
-            res[('finds', 'archaeological_finds__Find')]
-        )
+        find_json = json.loads(res[("finds", "archaeological_finds__Find")])
         self.assertEqual(len(find_json), 2)
-        bfind_json = json.loads(
-            res[('finds', 'archaeological_finds__BaseFind')]
-        )
+        bfind_json = json.loads(res[("finds", "archaeological_finds__BaseFind")])
         self.assertEqual(len(bfind_json), 2)
 
         result_queryset = Operation.objects.filter(uuid=self.operations[0].uuid)
         res = self.generic_serialization_test(
-            serializers.find_serialization, no_test=True,
-            kwargs={"operation_queryset": result_queryset}
-        )
-        find_json = json.loads(
-            res[('finds', 'archaeological_finds__Find')]
+            serializers.find_serialization,
+            no_test=True,
+            kwargs={"operation_queryset": result_queryset},
         )
+        find_json = json.loads(res[("finds", "archaeological_finds__Find")])
         self.assertEqual(len(find_json), 1)
-        bfind_json = json.loads(
-            res[('finds', 'archaeological_finds__BaseFind')]
-        )
+        bfind_json = json.loads(res[("finds", "archaeological_finds__BaseFind")])
         self.assertEqual(len(bfind_json), 1)
 
         result_queryset = ContextRecord.objects.filter(
-            uuid=self.context_records[0].uuid)
-        res = self.generic_serialization_test(
-            serializers.find_serialization, no_test=True,
-            kwargs={"cr_queryset": result_queryset}
+            uuid=self.context_records[0].uuid
         )
-        find_json = json.loads(
-            res[('finds', 'archaeological_finds__Find')]
+        res = self.generic_serialization_test(
+            serializers.find_serialization,
+            no_test=True,
+            kwargs={"cr_queryset": result_queryset},
         )
+        find_json = json.loads(res[("finds", "archaeological_finds__Find")])
         self.assertEqual(len(find_json), 1)
-        bfind_json = json.loads(
-            res[('finds', 'archaeological_finds__BaseFind')]
-        )
+        bfind_json = json.loads(res[("finds", "archaeological_finds__BaseFind")])
         self.assertEqual(len(bfind_json), 1)
 
-        result_queryset = models.Find.objects.filter(
-            uuid=self.finds[0].uuid)
+        result_queryset = models.Find.objects.filter(uuid=self.finds[0].uuid)
         res = self.generic_serialization_test(
-            serializers.find_serialization, no_test=True,
-            kwargs={"find_queryset": result_queryset}
-        )
-        find_json = json.loads(
-            res[('finds', 'archaeological_finds__Find')]
+            serializers.find_serialization,
+            no_test=True,
+            kwargs={"find_queryset": result_queryset},
         )
+        find_json = json.loads(res[("finds", "archaeological_finds__Find")])
         self.assertEqual(len(find_json), 1)
-        bfind_json = json.loads(
-            res[('finds', 'archaeological_finds__BaseFind')]
-        )
+        bfind_json = json.loads(res[("finds", "archaeological_finds__BaseFind")])
         self.assertEqual(len(bfind_json), 1)
 
     def test_ope_serialization_with_find_filter(self):
         res = self.generic_serialization_test(
-            operation_serialization, no_test=True,
+            operation_serialization,
+            no_test=True,
         )
         ope_json = json.loads(
-            res[('operations', 'archaeological_operations__Operation')]
+            res[("operations", "archaeological_operations__Operation")]
         )
         self.assertEqual(len(ope_json), 2)
 
-        result_queryset = models.Find.objects.filter(
-            uuid=self.finds[0].uuid)
+        result_queryset = models.Find.objects.filter(uuid=self.finds[0].uuid)
         res = self.generic_serialization_test(
-            operation_serialization, no_test=True,
-            kwargs={"find_queryset": result_queryset}
+            operation_serialization,
+            no_test=True,
+            kwargs={"find_queryset": result_queryset},
         )
         ope_json = json.loads(
-            res[('operations', 'archaeological_operations__Operation')]
+            res[("operations", "archaeological_operations__Operation")]
         )
         self.assertEqual(len(ope_json), 1)
 
     def test_cr_serialization_with_find_filter(self):
         res = self.generic_serialization_test(
-            cr_serialization, no_test=True,
+            cr_serialization,
+            no_test=True,
         )
         cr_json = json.loads(
-            res[('context_records',
-                 'archaeological_context_records__ContextRecord')]
+            res[("context_records", "archaeological_context_records__ContextRecord")]
         )
         self.assertEqual(len(cr_json), 2)
 
-        result_queryset = models.Find.objects.filter(
-            uuid=self.finds[0].uuid)
+        result_queryset = models.Find.objects.filter(uuid=self.finds[0].uuid)
         res = self.generic_serialization_test(
-            cr_serialization, no_test=True,
-            kwargs={"find_queryset": result_queryset}
+            cr_serialization, no_test=True, kwargs={"find_queryset": result_queryset}
         )
         cr_json = json.loads(
-            res[('context_records',
-                 'archaeological_context_records__ContextRecord')]
+            res[("context_records", "archaeological_context_records__ContextRecord")]
         )
         self.assertEqual(len(cr_json), 1)
 
     def test_restore(self):
         current_number, zip_filename = self.generic_restore_test_genzip(
-            serializers.FIND_MODEL_LIST,
-            serializers.find_serialization)
-        self.generic_restore_test(zip_filename, current_number,
-                                  serializers.FIND_MODEL_LIST)
+            serializers.FIND_MODEL_LIST, serializers.find_serialization
+        )
+        self.generic_restore_test(
+            zip_filename, current_number, serializers.FIND_MODEL_LIST
+        )
 
 
 class FindWizardCreationTest(WizardTest, FindInit, TestCase):
     fixtures = WAREHOUSE_FIXTURES
-    url_name = 'find_creation'
-    wizard_name = 'find_wizard'
+    url_name = "find_creation"
+    wizard_name = "find_wizard"
     steps = views.find_creation_steps
-    redirect_url = "/find_modification/selec-find_modification?open_item="\
-                   "{last_id}"
+    redirect_url = "/find_modification/selec-find_modification?open_item=" "{last_id}"
     model = models.Find
     form_datas = [
         FormData(
-            'Find creation',
+            "Find creation",
             form_datas={
-                'selecrecord-find_creation': {'pk': 1},
-                'find-find_creation': {
-                    'label': 'hop',
-                    'checked': 'NC',
-                    'check_date': '2016-01-01'
+                "selecrecord-find_creation": {"pk": 1},
+                "find-find_creation": {
+                    "label": "hop",
+                    "checked": "NC",
+                    "check_date": "2016-01-01",
                 },
-                'dating-find_creation': [
+                "dating-find_creation": [
                     {
-                        'period': None,
-                        'start_date': '0',
-                        'end_date': '200',
+                        "period": None,
+                        "start_date": "0",
+                        "end_date": "200",
                     },
                     {
-                        'period': None,
-                        'start_date': '0',
-                        'end_date': '200',
-                    }
-                ]
+                        "period": None,
+                        "start_date": "0",
+                        "end_date": "200",
+                    },
+                ],
             },
-            ignored=['preservation-find_creation']
+            ignored=["preservation-find_creation"],
         )
     ]
 
     def pre_wizard(self):
         cr = self.create_context_record(
-            data={'parcel': self.create_parcel()[-1]}, force=True)[-1]
+            data={"parcel": self.create_parcel()[-1]}, force=True
+        )[-1]
 
-        self.form_datas[0].form_datas['selecrecord-find_creation']['pk'] = \
-            cr.pk
+        self.form_datas[0].form_datas["selecrecord-find_creation"]["pk"] = cr.pk
         period = Period.objects.all()[0].pk
-        self.form_datas[0].form_datas['dating-find_creation'][0]['period'] = \
-            period
-        self.form_datas[0].form_datas['dating-find_creation'][1]['period'] = \
-            period
+        self.form_datas[0].form_datas["dating-find_creation"][0]["period"] = period
+        self.form_datas[0].form_datas["dating-find_creation"][1]["period"] = period
         self.find_number = models.Find.objects.count()
         self.basefind_number = models.BaseFind.objects.count()
         super(FindWizardCreationTest, self).pre_wizard()
 
     def post_wizard(self):
-        self.assertEqual(models.BaseFind.objects.count(),
-                         self.basefind_number + 1)
-        self.assertEqual(models.Find.objects.count(),
-                         self.find_number + 1)
+        self.assertEqual(models.BaseFind.objects.count(), self.basefind_number + 1)
+        self.assertEqual(models.Find.objects.count(), self.find_number + 1)
         # identical datings, only one should be finaly save
         f = models.Find.objects.order_by("-pk").all()[0]
         self.assertEqual(f.datings.count(), 1)
@@ -307,42 +323,44 @@ class FindWizardCreationTest(WizardTest, FindInit, TestCase):
 
 class FindWizardModificationTest(WizardTest, FindInit, TestCase):
     fixtures = WAREHOUSE_FIXTURES
-    url_name = 'find_modification'
-    wizard_name = url_name + '_wizard'
+    url_name = "find_modification"
+    wizard_name = url_name + "_wizard"
     steps = views.find_modification_steps
-    redirect_url = "/find_modification/selec-find_modification?open_item=" \
-                   "{last_id}"
+    redirect_url = "/find_modification/selec-find_modification?open_item=" "{last_id}"
     model = models.Find
     form_datas = [
         FormData(
-            'Find modification',
+            "Find modification",
             form_datas={
-                'selec-find_modification': {'pk': ''},
-                'selecrecord-find_modification': {
+                "selec-find_modification": {"pk": ""},
+                "selecrecord-find_modification": {
                     "get_first_base_find__context_record": ""
                 },
-                'find-find_modification': {
-                    'label': 'hop',
-                    'checked': 'NC',
-                    'check_date': '2016-01-01'
+                "find-find_modification": {
+                    "label": "hop",
+                    "checked": "NC",
+                    "check_date": "2016-01-01",
                 },
-                'dating-find_modification': [
+                "dating-find_modification": [
                     {
-                        'period': None,
-                        'start_date': '',
-                        'end_date': '',
+                        "period": None,
+                        "start_date": "",
+                        "end_date": "",
                     },
-                ]
+                ],
             },
-            ignored=['preservation-find_modification',
-                     'selecw-find_modification',
-                     'simplefind-find_modification']
+            ignored=[
+                "preservation-find_modification",
+                "selecw-find_modification",
+                "simplefind-find_modification",
+            ],
         )
     ]
 
     def pre_wizard(self):
         profile, created = IshtarSiteProfile.objects.get_or_create(
-            slug='default', active=True)
+            slug="default", active=True
+        )
         profile.warehouse = False
         profile.save()
         find, __ = self.get_default_find(force=True)
@@ -352,29 +370,28 @@ class FindWizardModificationTest(WizardTest, FindInit, TestCase):
         find.save()
         data = self.form_datas[0].form_datas
 
-        data['selec-find_modification']['pk'] = find.pk
-        data['selecrecord-find_modification'][
-            'get_first_base_find__context_record'] = \
-            find.base_finds.all()[0].context_record.pk
+        data["selec-find_modification"]["pk"] = find.pk
+        data["selecrecord-find_modification"][
+            "get_first_base_find__context_record"
+        ] = find.base_finds.all()[0].context_record.pk
 
         self.period = Period.objects.all()[0]
         self.period2 = Period.objects.all()[1]
 
-        find.datings.add(Dating.objects.create(
-            period=self.period, start_date='0', end_date='200'))
+        find.datings.add(
+            Dating.objects.create(period=self.period, start_date="0", end_date="200")
+        )
         find.datings.add(Dating.objects.create(period=self.period2))
 
-        data['dating-find_modification'][0]['period'] = self.period.pk
+        data["dating-find_modification"][0]["period"] = self.period.pk
         self.find_number = models.Find.objects.count()
         self.basefind_number = models.BaseFind.objects.count()
         super(FindWizardModificationTest, self).pre_wizard()
 
     def post_wizard(self):
         # no creation
-        self.assertEqual(models.BaseFind.objects.count(),
-                         self.basefind_number)
-        self.assertEqual(models.Find.objects.count(),
-                         self.find_number)
+        self.assertEqual(models.BaseFind.objects.count(), self.basefind_number)
+        self.assertEqual(models.Find.objects.count(), self.find_number)
         f = models.Find.objects.get(pk=self.find.pk)
         self.assertEqual(f.datings.count(), 1)
         dating = f.datings.all()[0]
@@ -385,109 +402,109 @@ class FindWizardModificationTest(WizardTest, FindInit, TestCase):
 
 class FindWizardDeletionWithWarehouseModTest(WizardTest, FindInit, TestCase):
     fixtures = WAREHOUSE_FIXTURES
-    url_name = 'find_deletion'
-    wizard_name = 'find_deletion_wizard'
+    url_name = "find_deletion"
+    wizard_name = "find_deletion_wizard"
     steps = views.find_deletion_steps
     redirect_url = "/{}/selecw-{}".format(url_name, url_name)
     form_datas = [
         FormData(
-            'Find deletion',
+            "Find deletion",
             form_datas={
-                'selecw': {},
+                "selecw": {},
             },
-            ignored=['selec-find_deletion']
+            ignored=["selec-find_deletion"],
         )
     ]
 
     def pre_wizard(self):
         profile, created = IshtarSiteProfile.objects.get_or_create(
-            slug='default', active=True)
+            slug="default", active=True
+        )
         profile.warehouse = True
         profile.save()
 
         find, bf = self.get_default_find(force=True)
-        self.form_datas[0].set('selecw', 'pks', find.pk)
+        self.form_datas[0].set("selecw", "pks", find.pk)
         self.find_number = models.Find.objects.count()
         super(FindWizardDeletionWithWarehouseModTest, self).pre_wizard()
 
     def post_wizard(self):
-        self.assertEqual(models.Find.objects.count(),
-                         self.find_number - 1)
+        self.assertEqual(models.Find.objects.count(), self.find_number - 1)
 
 
 class TreatmentWizardCreationTest(WizardTest, FindInit, TestCase):
     fixtures = WAREHOUSE_FIXTURES
-    url_name = 'treatment_creation'
-    wizard_name = 'treatment_wizard'
+    url_name = "treatment_creation"
+    wizard_name = "treatment_wizard"
     steps = views.treatment_wizard_steps
-    redirect_url = "/treatment_search/general-treatment_search?" \
-                   "open_item={last_id}"
+    redirect_url = "/treatment_search/general-treatment_search?" "open_item={last_id}"
     model = models.Treatment
     form_datas = [
         FormData(
-            'Move treatment (planned)',
+            "Move treatment (planned)",
             form_datas={
-                'file': {},
-                'basetreatment': {
-                    'treatment_type': None,
-                    'person': 1,  # doer
-                    'location': 1,  # associated warehouse
-                    'year': 2016,
-                    'container': None,
+                "file": {},
+                "basetreatment": {
+                    "treatment_type": None,
+                    "person": 1,  # doer
+                    "location": 1,  # associated warehouse
+                    "year": 2016,
+                    "container": None,
                 },
-                'selecfind': {
-                    'pk': 1,
-                    'resulting_pk': 1
-                }
+                "selecfind": {"pk": 1, "resulting_pk": 1},
             },
-            ignored=('resultfind-treatment_creation',
-                     'selecbasket-treatment_creation',
-                     'resultfinds-treatment_creation')),
+            ignored=(
+                "resultfind-treatment_creation",
+                "selecbasket-treatment_creation",
+                "resultfinds-treatment_creation",
+            ),
+        ),
         FormData(
-            'Move treatment (done)',
+            "Move treatment (done)",
             form_datas={
-                'file': {},
-                'basetreatment': {
-                    'treatment_type': None,
-                    'person': 1,  # doer
-                    'location': 1,  # associated warehouse
-                    'year': 2016,
-                    'container': None,
+                "file": {},
+                "basetreatment": {
+                    "treatment_type": None,
+                    "person": 1,  # doer
+                    "location": 1,  # associated warehouse
+                    "year": 2016,
+                    "container": None,
                 },
-                'selecfind': {
-                    'pk': 1,
-                    'resulting_pk': 1
-                }
+                "selecfind": {"pk": 1, "resulting_pk": 1},
             },
-            ignored=('resultfind-treatment_creation',
-                     'selecbasket-treatment_creation',
-                     'resultfinds-treatment_creation')),
+            ignored=(
+                "resultfind-treatment_creation",
+                "selecbasket-treatment_creation",
+                "resultfinds-treatment_creation",
+            ),
+        ),
         FormData(
-            'Loan treatment (done)',
+            "Loan treatment (done)",
             form_datas={
-                'file': {},
-                'basetreatment': {
-                    'treatment_type': None,
-                    'person': 1,  # doer
-                    'location': 1,  # associated warehouse
-                    'year': 2016,
-                    'container': None,
+                "file": {},
+                "basetreatment": {
+                    "treatment_type": None,
+                    "person": 1,  # doer
+                    "location": 1,  # associated warehouse
+                    "year": 2016,
+                    "container": None,
                 },
-                'selecfind': {
-                    'pk': 1,
-                    'resulting_pk': 1
-                }
+                "selecfind": {"pk": 1, "resulting_pk": 1},
             },
-            ignored=('resultfind-treatment_creation',
-                     'selecbasket-treatment_creation',
-                     'resultfinds-treatment_creation')),
+            ignored=(
+                "resultfind-treatment_creation",
+                "selecbasket-treatment_creation",
+                "resultfinds-treatment_creation",
+            ),
+        ),
     ]
 
     def pre_wizard(self):
         q = Warehouse.objects.filter(pk=1)
         if not q.count():
             warehouse = Warehouse.objects.create(
-                name="default", warehouse_type=WarehouseType.objects.all()[0])
+                name="default", warehouse_type=WarehouseType.objects.all()[0]
+            )
             warehouse.id = 1
             warehouse.save()
         else:
@@ -501,19 +518,19 @@ class TreatmentWizardCreationTest(WizardTest, FindInit, TestCase):
         self.container_ref = Container.objects.create(
             location=warehouse,
             responsible=warehouse,
-            container_type=ContainerType.objects.all()[0]
+            container_type=ContainerType.objects.all()[0],
         )
 
         self.container1 = Container.objects.create(
             location=warehouse,
             responsible=warehouse,
-            container_type=ContainerType.objects.all()[0]
+            container_type=ContainerType.objects.all()[0],
         )
 
         self.container2 = Container.objects.create(
             location=warehouse,
             responsible=warehouse,
-            container_type=ContainerType.objects.all()[0]
+            container_type=ContainerType.objects.all()[0],
         )
 
         self.find, base_find = self.get_default_find(force=True)
@@ -521,50 +538,44 @@ class TreatmentWizardCreationTest(WizardTest, FindInit, TestCase):
         self.find.container = self.container_ref
         self.find.save()
         for idx in (0, 1):
-            self.form_datas[idx].form_datas['selecfind']["pk"] = self.find.pk
-            self.form_datas[idx].form_datas['selecfind']["resulting_pk"] = \
-                self.find.pk
-            self.form_datas[idx].set('basetreatment', 'container',
-                                     self.container1.pk)
+            self.form_datas[idx].form_datas["selecfind"]["pk"] = self.find.pk
+            self.form_datas[idx].form_datas["selecfind"]["resulting_pk"] = self.find.pk
+            self.form_datas[idx].set("basetreatment", "container", self.container1.pk)
 
         self.find_2, base_find = self.get_default_find(force=True)
         self.find_2.container_ref = self.container_ref
         self.find_2.container = self.container_ref
         self.find_2.save()
-        self.form_datas[2].form_datas['selecfind']["pk"] = self.find_2.pk
-        self.form_datas[2].form_datas['selecfind']["resulting_pk"] = \
-            self.find_2.pk
-        self.form_datas[2].set('basetreatment', 'container', self.container2.pk)
+        self.form_datas[2].form_datas["selecfind"]["pk"] = self.find_2.pk
+        self.form_datas[2].form_datas["selecfind"]["resulting_pk"] = self.find_2.pk
+        self.form_datas[2].set("basetreatment", "container", self.container2.pk)
 
-        moving = models.TreatmentType.objects.get(txt_idx='moving')
+        moving = models.TreatmentType.objects.get(txt_idx="moving")
         moving.change_reference_location = True
         moving.change_current_location = True
         moving.save()
-        self.form_datas[0].set('basetreatment', 'treatment_type',
-                               moving.pk)
-        self.form_datas[1].set('basetreatment', 'treatment_type',
-                               moving.pk)
-        loan = models.TreatmentType.objects.get(txt_idx='loan')
+        self.form_datas[0].set("basetreatment", "treatment_type", moving.pk)
+        self.form_datas[1].set("basetreatment", "treatment_type", moving.pk)
+        loan = models.TreatmentType.objects.get(txt_idx="loan")
         loan.change_reference_location = False
         loan.change_current_location = True
         loan.save()
-        self.form_datas[2].set('basetreatment', 'treatment_type',
-                               loan.pk)
+        self.form_datas[2].set("basetreatment", "treatment_type", loan.pk)
 
         planned, __ = models.TreatmentState.objects.get_or_create(
-            txt_idx='planned', defaults={"executed": False, "label": "Planned"}
+            txt_idx="planned", defaults={"executed": False, "label": "Planned"}
         )
         planned.executed = False
         planned.save()
-        self.form_datas[0].set('basetreatment', 'treatment_state', planned.pk)
+        self.form_datas[0].set("basetreatment", "treatment_state", planned.pk)
 
         completed, created = models.TreatmentState.objects.get_or_create(
-            txt_idx='completed', defaults={"executed": True, "label": "Done"}
+            txt_idx="completed", defaults={"executed": True, "label": "Done"}
         )
         completed.executed = True
         completed.save()
-        self.form_datas[1].set('basetreatment', 'treatment_state', completed.pk)
-        self.form_datas[2].set('basetreatment', 'treatment_state', completed.pk)
+        self.form_datas[1].set("basetreatment", "treatment_state", completed.pk)
+        self.form_datas[2].set("basetreatment", "treatment_state", completed.pk)
 
         self.treatment_number = models.Treatment.objects.count()
 
@@ -572,8 +583,8 @@ class TreatmentWizardCreationTest(WizardTest, FindInit, TestCase):
             # treatment planned - no changes
             find = models.Find.objects.get(pk=test_object.find.pk)
             test_object.assertEqual(find.container, test_object.container_ref)
-            test_object.assertEqual(find.container_ref,
-                                    test_object.container_ref)
+            test_object.assertEqual(find.container_ref, test_object.container_ref)
+
         self.form_datas[0].extra_tests = [post_first_wizard]
 
         def post_second_wizard(test_object, final_step_response):
@@ -581,21 +592,21 @@ class TreatmentWizardCreationTest(WizardTest, FindInit, TestCase):
             find = models.Find.objects.get(pk=test_object.find.pk)
             test_object.assertEqual(find.container, test_object.container1)
             test_object.assertEqual(find.container_ref, test_object.container1)
+
         self.form_datas[1].extra_tests = [post_second_wizard]
 
         def post_third_wizard(test_object, final_step_response):
             # loan done
             find = models.Find.objects.get(pk=test_object.find_2.pk)
-            test_object.assertEqual(find.container_ref,
-                                    test_object.container_ref)
+            test_object.assertEqual(find.container_ref, test_object.container_ref)
             test_object.assertEqual(find.container, test_object.container2)
+
         self.form_datas[2].extra_tests = [post_third_wizard]
 
         super(TreatmentWizardCreationTest, self).pre_wizard()
 
     def post_wizard(self):
-        self.assertEqual(models.Treatment.objects.count(),
-                         self.treatment_number + 3)
+        self.assertEqual(models.Treatment.objects.count(), self.treatment_number + 3)
         self.find = models.Find.objects.get(pk=self.find.pk)
         self.assertEqual(self.find.treatments.count(), 2)
         self.find_2 = models.Find.objects.get(pk=self.find_2.pk)
@@ -608,8 +619,7 @@ class TreatmentWizardCreationTest(WizardTest, FindInit, TestCase):
 
 class ImportFindTest(ImportTest, FindInit, TestCase):
     fixtures = FIND_TOWNS_FIXTURES + [
-        settings.ROOT_PATH +
-        '../archaeological_finds/tests/import_loca_test.json',
+        settings.ROOT_PATH + "../archaeological_finds/tests/import_loca_test.json",
     ]
 
     def setUp(self):
@@ -623,38 +633,42 @@ class ImportFindTest(ImportTest, FindInit, TestCase):
         old_nb_find = models.Find.objects.count()
         MCC = ImporterType.objects.get(name="MCC - Mobilier")
 
-        col = ImporterColumn.objects.create(col_number=25,
-                                            importer_type_id=MCC.pk)
-        formater = FormaterType.objects.filter(
-            formater_type='FileFormater').all()[0]
-        ImportTarget.objects.create(target='documents__image',
-                                    formater_type_id=formater.pk,
-                                    column_id=col.pk)
+        col = ImporterColumn.objects.create(col_number=25, importer_type_id=MCC.pk)
+        formater = FormaterType.objects.filter(formater_type="FileFormater").all()[0]
+        ImportTarget.objects.create(
+            target="documents__image", formater_type_id=formater.pk, column_id=col.pk
+        )
         mcc_file = open(
-            settings.ROOT_PATH +
-            '../archaeological_finds/tests/MCC-finds-example.csv', 'rb')
+            settings.ROOT_PATH + "../archaeological_finds/tests/MCC-finds-example.csv",
+            "rb",
+        )
         mcc_images = open(
-            settings.ROOT_PATH +
-            '../archaeological_finds/tests/images.zip', 'rb')
-        file_dict = {'imported_file': SimpleUploadedFile(mcc_file.name,
-                                                         mcc_file.read()),
-                     'imported_images': SimpleUploadedFile(mcc_images.name,
-                                                           mcc_images.read())}
-        post_dict = {'importer_type': MCC.pk, 'skip_lines': 1,
-                     "encoding": 'utf-8', "name": 'init_find_import',
-                     "csv_sep": ","}
-        form = forms_common.NewImportForm(data=post_dict, files=file_dict,
-                                          user=self.user)
+            settings.ROOT_PATH + "../archaeological_finds/tests/images.zip", "rb"
+        )
+        file_dict = {
+            "imported_file": SimpleUploadedFile(mcc_file.name, mcc_file.read()),
+            "imported_images": SimpleUploadedFile(mcc_images.name, mcc_images.read()),
+        }
+        post_dict = {
+            "importer_type": MCC.pk,
+            "skip_lines": 1,
+            "encoding": "utf-8",
+            "name": "init_find_import",
+            "csv_sep": ",",
+        }
+        form = forms_common.NewImportForm(
+            data=post_dict, files=file_dict, user=self.user
+        )
         form.is_valid()
         self.assertTrue(form.is_valid())
         impt = form.save(self.ishtar_user)
         impt.initialize()
 
         # doing manual connections
-        ceram = models.MaterialType.objects.get(txt_idx='ceramic').pk
-        glass = models.MaterialType.objects.get(txt_idx='glass').pk
-        self.set_target_key('material_types', 'terre-cuite', ceram)
-        self.set_target_key('material_types', 'verre', glass)
+        ceram = models.MaterialType.objects.get(txt_idx="ceramic").pk
+        glass = models.MaterialType.objects.get(txt_idx="glass").pk
+        self.set_target_key("material_types", "terre-cuite", ceram)
+        self.set_target_key("material_types", "verre", glass)
         impt.importation()
         # new finds has now been imported
         current_nb = models.BaseFind.objects.count()
@@ -662,9 +676,11 @@ class ImportFindTest(ImportTest, FindInit, TestCase):
         current_nb = models.Find.objects.count()
         self.assertEqual(current_nb, (old_nb_find + 4))
         self.assertEqual(
-            models.Find.objects.filter(material_types__pk=ceram).count(), 4)
+            models.Find.objects.filter(material_types__pk=ceram).count(), 4
+        )
         self.assertEqual(
-            models.Find.objects.filter(material_types__pk=glass).count(), 1)
+            models.Find.objects.filter(material_types__pk=glass).count(), 1
+        )
         images = []
         for find in models.Find.objects.all():
             images += [1 for im in find.images.all() if im.image.name]
@@ -676,15 +692,19 @@ class ImportFindTest(ImportTest, FindInit, TestCase):
             bf = bfs[idx]
             expected_index = 4 - idx
             self.assertEqual(
-                bf.index, expected_index,
+                bf.index,
+                expected_index,
                 "Bad index for imported base find: {} where {} is "
-                "expected".format(bf.index, expected_index))
+                "expected".format(bf.index, expected_index),
+            )
             f = bf.find.all()[0]
             self.assertEqual(
-                f.index, expected_index,
+                f.index,
+                expected_index,
                 "Bad index for imported find: {} where {} is expected".format(
                     f.index, expected_index
-                ))
+                ),
+            )
 
     def test_import_locations(self):
         self.create_finds()
@@ -701,8 +721,7 @@ class ImportFindTest(ImportTest, FindInit, TestCase):
 
         warehouse, __ = Warehouse.objects.get_or_create(
             external_id="warehouse-test",
-            defaults={"name": "Warehouse test",
-                      "warehouse_type": wt}
+            defaults={"name": "Warehouse test", "warehouse_type": wt},
         )
 
         container_types = []
@@ -717,7 +736,7 @@ class ImportFindTest(ImportTest, FindInit, TestCase):
             WarehouseDivisionLink.objects.get_or_create(
                 warehouse=warehouse,
                 container_type=container_types[idx],
-                order=(idx + 1) * 10
+                order=(idx + 1) * 10,
             )
 
         old_nb = models.BaseFind.objects.count()
@@ -730,29 +749,56 @@ class ImportFindTest(ImportTest, FindInit, TestCase):
 
         with open(imp_filename, "w") as impfile:
             w = csv.writer(impfile)
-            w.writerow(['External ID', "Warehouse", "Ref.",
-                        "Container type", "Localisation 1", "Localisation 2",
-                        "Localisation 3"])
+            w.writerow(
+                [
+                    "External ID",
+                    "Warehouse",
+                    "Ref.",
+                    "Container type",
+                    "Localisation 1",
+                    "Localisation 2",
+                    "Localisation 3",
+                ]
+            )
             for idx, ext_id in enumerate(external_ids):
                 if idx < 2:
-                    w.writerow([ext_id, "warehouse-test",
-                                "Réf. {}".format((idx + 1) * 10),
-                                container_types[-1].name,
-                                "A", "42", idx + 1])
+                    w.writerow(
+                        [
+                            ext_id,
+                            "warehouse-test",
+                            "Réf. {}".format((idx + 1) * 10),
+                            container_types[-1].name,
+                            "A",
+                            "42",
+                            idx + 1,
+                        ]
+                    )
                 else:
-                    w.writerow([ext_id, "warehouse-test",
-                                "Réf. {}".format((idx + 1) * 10),
-                                container_types[-1].name,
-                                "A", 43])
+                    w.writerow(
+                        [
+                            ext_id,
+                            "warehouse-test",
+                            "Réf. {}".format((idx + 1) * 10),
+                            container_types[-1].name,
+                            "A",
+                            43,
+                        ]
+                    )
 
         imp_file = open(imp_filename, "rb")
-        file_dict = {'imported_file': SimpleUploadedFile(imp_file.name,
-                                                         imp_file.read())}
-        post_dict = {'importer_type': importer_type.pk, 'skip_lines': 1,
-                     "encoding": 'utf-8', "name": 'init_find_import',
-                     "csv_sep": ","}
-        form = forms_common.NewImportForm(data=post_dict, files=file_dict,
-                                          user=self.user)
+        file_dict = {
+            "imported_file": SimpleUploadedFile(imp_file.name, imp_file.read())
+        }
+        post_dict = {
+            "importer_type": importer_type.pk,
+            "skip_lines": 1,
+            "encoding": "utf-8",
+            "name": "init_find_import",
+            "csv_sep": ",",
+        }
+        form = forms_common.NewImportForm(
+            data=post_dict, files=file_dict, user=self.user
+        )
         form.is_valid()
         self.assertTrue(form.is_valid())
         impt = form.save(self.ishtar_user)
@@ -807,12 +853,15 @@ class ImportFindTest(ImportTest, FindInit, TestCase):
             self.assertIn(box.parent_id, [s.pk for s in areas])
 
         importer_type = ImporterType.objects.get(slug="importeur-test")
-        cols = list(ImporterColumn.objects.filter(
-            importer_type=importer_type,
-            col_number__gte=5).values_list("id", flat=True))
+        cols = list(
+            ImporterColumn.objects.filter(
+                importer_type=importer_type, col_number__gte=5
+            ).values_list("id", flat=True)
+        )
         for target in ImportTarget.objects.filter(column_id__in=cols):
-            target.target = target.target.replace("set_localisation",
-                                                  "set_static_localisation")
+            target.target = target.target.replace(
+                "set_localisation", "set_static_localisation"
+            )
             target.save()
 
         # delete area 43 and all boxes
@@ -826,9 +875,9 @@ class ImportFindTest(ImportTest, FindInit, TestCase):
         self.assertEqual(len(impt.errors), 2)
         for error in impt.errors:
             self.assertEqual(
-                error['error'],
-                "The division Area 43 do not exist for the location Warehouse "
-                "test.")
+                error["error"],
+                "The division Area 43 do not exist for the location Warehouse " "test.",
+            )
 
     def tearDown(self):
         self.tmpdir.cleanup()
@@ -840,10 +889,9 @@ class FindTest(FindInit, TestCase):
 
     def setUp(self):
         self.create_finds(force=True)
-        self.password = 'mypassword'
-        self.username = 'myuser'
-        User.objects.create_superuser(self.username, 'myemail@test.com',
-                                      self.password)
+        self.password = "mypassword"
+        self.username = "myuser"
+        User.objects.create_superuser(self.username, "myemail@test.com", self.password)
         self.client = Client()
         self.client.login(username=self.username, password=self.password)
 
@@ -853,21 +901,20 @@ class FindTest(FindInit, TestCase):
         self.assertEqual(
             find.external_id,
             "{}-{}".format(
-                find.get_first_base_find().context_record.external_id,
-                find.label))
+                find.get_first_base_find().context_record.external_id, find.label
+            ),
+        )
         self.assertEqual(
             base_find.external_id,
-            "{}-{}".format(
-                base_find.context_record.external_id,
-                base_find.label))
+            "{}-{}".format(base_find.context_record.external_id, base_find.label),
+        )
         base_find.label = "New label"
         base_find.save()
         base_find = models.BaseFind.objects.get(pk=base_find.pk)
         self.assertEqual(
             base_find.external_id,
-            "{}-{}".format(
-                base_find.context_record.external_id,
-                "New label"))
+            "{}-{}".format(base_find.context_record.external_id, "New label"),
+        )
         cr = ContextRecord.objects.get(pk=base_find.context_record.pk)
         cr.label = "new-label-too"
         cr.skip_history_when_saving = True
@@ -893,22 +940,21 @@ class FindTest(FindInit, TestCase):
         # default: {get_first_base_find__context_record__external_id}-{label}
         self.assertEqual(find.external_id, "PAT-12345-A1-new-label-too-hop")
         profile = get_current_profile(force=True)
-        profile.find_external_id = \
-            "{get_first_base_find__context_record__external_id}-{label}-"\
-            "{label}"
+        profile.find_external_id = (
+            "{get_first_base_find__context_record__external_id}-{label}-" "{label}"
+        )
         profile.save()
         find.save()
         find = models.Find.objects.get(pk=find.pk)
-        self.assertEqual(find.external_id,
-                         "PAT-12345-A1-new-label-too-hop-hop")
-        profile.find_external_id = \
-            "{get_first_base_find__context_record__external_id}-{label}-" \
+        self.assertEqual(find.external_id, "PAT-12345-A1-new-label-too-hop-hop")
+        profile.find_external_id = (
+            "{get_first_base_find__context_record__external_id}-{label}-"
             "{label}||lower||deduplicate"
+        )
         profile.save()
         find.save()
         find = models.Find.objects.get(pk=find.pk)
-        self.assertEqual(find.external_id,
-                         "pat-12345-a1-new-label-too-hop")
+        self.assertEqual(find.external_id, "pat-12345-a1-new-label-too-hop")
 
     def testIndex(self):
         profile = get_current_profile()
@@ -918,26 +964,29 @@ class FindTest(FindInit, TestCase):
 
         op1 = self.create_operation()[-1]
         op2 = self.create_operation()[-1]
-        op1_cr1 = self.create_context_record(data={'label': "CR1",
-                                                   'operation': op1})[-1]
-        op1_cr2 = self.create_context_record(data={'label': "CR2",
-                                                   'operation': op1})[-1]
-        op2_cr1 = self.create_context_record(data={'label': "CR3",
-                                                   'operation': op2})[-1]
-        self.create_finds(data_base={'context_record': op1_cr1})
+        op1_cr1 = self.create_context_record(data={"label": "CR1", "operation": op1})[
+            -1
+        ]
+        op1_cr2 = self.create_context_record(data={"label": "CR2", "operation": op1})[
+            -1
+        ]
+        op2_cr1 = self.create_context_record(data={"label": "CR3", "operation": op2})[
+            -1
+        ]
+        self.create_finds(data_base={"context_record": op1_cr1})
         find_1 = self.finds[-1]
         bf_1 = models.BaseFind.objects.get(pk=self.base_finds[-1].pk)
         self.assertEqual(find_1.index, 1)
         self.assertEqual(bf_1.index, 1)
 
         # index is based on operations
-        self.create_finds(data_base={'context_record': op1_cr2})
+        self.create_finds(data_base={"context_record": op1_cr2})
         find_2 = self.finds[-1]
         bf_2 = models.BaseFind.objects.get(pk=self.base_finds[-1].pk)
         self.assertEqual(find_2.index, 2)
         self.assertEqual(bf_2.index, 2)
 
-        self.create_finds(data_base={'context_record': op2_cr1})
+        self.create_finds(data_base={"context_record": op2_cr1})
         find_3 = self.finds[-1]
         bf_3 = models.BaseFind.objects.get(pk=self.base_finds[-1].pk)
         self.assertEqual(find_3.index, 1)
@@ -949,24 +998,26 @@ class FindTest(FindInit, TestCase):
         profile = get_current_profile(force=True)
 
         op3 = self.create_operation()[-1]
-        op3_cr1 = self.create_context_record(data={'label': "CR1",
-                                                   'operation': op3})[-1]
-        op3_cr2 = self.create_context_record(data={'label': "CR2",
-                                                   'operation': op3})[-1]
-        self.create_finds(data_base={'context_record': op3_cr1})
+        op3_cr1 = self.create_context_record(data={"label": "CR1", "operation": op3})[
+            -1
+        ]
+        op3_cr2 = self.create_context_record(data={"label": "CR2", "operation": op3})[
+            -1
+        ]
+        self.create_finds(data_base={"context_record": op3_cr1})
         find_1b = self.finds[-1]
         bf_1b = models.BaseFind.objects.get(pk=self.base_finds[-1].pk)
         self.assertEqual(find_1b.index, 1)
         self.assertEqual(bf_1b.index, 1)
 
         # index now based on context records
-        self.create_finds(data_base={'context_record': op3_cr2})
+        self.create_finds(data_base={"context_record": op3_cr2})
         find_2b = self.finds[-1]
         bf_2b = models.BaseFind.objects.get(pk=self.base_finds[-1].pk)
         self.assertEqual(find_2b.index, 1)
         self.assertEqual(bf_2b.index, 1)
 
-        self.create_finds(data_base={'context_record': op3_cr2})
+        self.create_finds(data_base={"context_record": op3_cr2})
         find_3b = self.finds[-1]
         bf_3b = models.BaseFind.objects.get(pk=self.base_finds[-1].pk)
         self.assertEqual(find_3b.index, 2)
@@ -974,17 +1025,18 @@ class FindTest(FindInit, TestCase):
 
     def test_show(self):
         obj = self.finds[0]
-        response = self.client.get(reverse('display-find', args=[obj.pk]))
+        response = self.client.get(reverse("display-find", args=[obj.pk]))
         self.assertEqual(response.status_code, 200)
-        self.assertIn('load_window("/show-find/{}/");'.format(obj.pk),
-                      response.content.decode())
+        self.assertIn(
+            'load_window("/show-find/{}/");'.format(obj.pk), response.content.decode()
+        )
         c = Client()
-        response = c.get(reverse('show-find', kwargs={'pk': obj.pk}))
+        response = c.get(reverse("show-find", kwargs={"pk": obj.pk}))
         # empty content when not allowed
         self.assertRedirects(response, "/")
 
         c.login(username=self.username, password=self.password)
-        response = self.client.get(reverse('show-find', kwargs={'pk': obj.pk}))
+        response = self.client.get(reverse("show-find", kwargs={"pk": obj.pk}))
         self.assertEqual(response.status_code, 200)
         self.assertIn(b'class="card sheet"', response.content)
 
@@ -996,11 +1048,13 @@ class FindTest(FindInit, TestCase):
         self.finds[0].delete()
         # on delete the selected base find is not deleted if another find
         # is related to it
-        self.assertEqual(models.BaseFind.objects.filter(
-            pk=self.base_finds[0].pk).count(), 1)
+        self.assertEqual(
+            models.BaseFind.objects.filter(pk=self.base_finds[0].pk).count(), 1
+        )
         self.finds[1].delete()
-        self.assertEqual(models.BaseFind.objects.filter(
-            pk=self.base_finds[0].pk).count(), 0)
+        self.assertEqual(
+            models.BaseFind.objects.filter(pk=self.base_finds[0].pk).count(), 0
+        )
 
     def test_get_material_types(self):
         mat0 = models.MaterialType.objects.all()[0]
@@ -1014,71 +1068,68 @@ class FindTest(FindInit, TestCase):
         find0.material_types.add(mat1)
 
         self.assertEqual(
-            find0.get_material_types(),
-            ", ".join(sorted([mat0.label, mat1.label])))
+            find0.get_material_types(), ", ".join(sorted([mat0.label, mat1.label]))
+        )
         self.assertEqual(
-            find0.get_material_types_code(),
-            "|".join(sorted([mat0.code, mat1.code])))
+            find0.get_material_types_code(), "|".join(sorted([mat0.code, mat1.code]))
+        )
 
 
 class FindSearchTest(FindInit, TestCase, SearchText):
     fixtures = WAREHOUSE_FIXTURES
     model = models.Find
-    SEARCH_URL = 'get-find'
+    SEARCH_URL = "get-find"
 
     def setUp(self):
         self.create_finds(force=True)
         self.create_finds(force=True)
-        self.username = 'myuser'
-        self.password = 'mypassword'
-        User.objects.create_superuser(self.username, 'myemail@test.com',
-                                      self.password)
+        self.username = "myuser"
+        self.password = "mypassword"
+        User.objects.create_superuser(self.username, "myemail@test.com", self.password)
         self.client = Client()
 
     def test_material_type_hierarchic_search(self):
         find = self.finds[0]
         c = Client()
-        metal = models.MaterialType.objects.get(txt_idx='metal')
-        iron_metal = models.MaterialType.objects.get(txt_idx='iron_metal')
-        not_iron_metal = models.MaterialType.objects.get(
-            txt_idx='not_iron_metal')
+        metal = models.MaterialType.objects.get(txt_idx="metal")
+        iron_metal = models.MaterialType.objects.get(txt_idx="iron_metal")
+        not_iron_metal = models.MaterialType.objects.get(txt_idx="not_iron_metal")
         find.material_types.add(iron_metal)
         find = models.Find.objects.get(pk=find.pk)
         find.save()
 
-        search = {'material_types': iron_metal.pk}
+        search = {"material_types": iron_metal.pk}
 
         # no result when no authentication
-        response = c.get(reverse('get-find'), search)
+        response = c.get(reverse("get-find"), search)
         self.assertRedirects(response, "/")
 
         c.login(username=self.username, password=self.password)
 
         # one result for exact search
-        response = c.get(reverse('get-find'), search)
+        response = c.get(reverse("get-find"), search)
         self.assertEqual(response.status_code, 200)
         content = response.content.decode()
         res = json.loads(content)
-        self.assertEqual(res['recordsTotal'], 1)
-        self.assertEqual(res["rows"][0]["cached_materials"],
-                         str(iron_metal))
+        self.assertEqual(res["recordsTotal"], 1)
+        self.assertEqual(res["rows"][0]["cached_materials"], str(iron_metal))
 
         # no result for the brother
-        search = {'material_types': not_iron_metal.pk}
-        response = c.get(reverse('get-find'), search)
+        search = {"material_types": not_iron_metal.pk}
+        response = c.get(reverse("get-find"), search)
         self.assertEqual(response.status_code, 200)
         content = response.content.decode()
-        self.assertEqual(json.loads(content)['recordsTotal'], 0)
+        self.assertEqual(json.loads(content)["recordsTotal"], 0)
 
         # one result for the father
-        search = {'material_types': metal.pk}
-        response = c.get(reverse('get-find'), search)
+        search = {"material_types": metal.pk}
+        response = c.get(reverse("get-find"), search)
         self.assertEqual(response.status_code, 200)
         content = response.content.decode()
-        self.assertEqual(json.loads(content)['recordsTotal'], 1)
+        self.assertEqual(json.loads(content)["recordsTotal"], 1)
 
         # test on text search
-        material_key = str(pgettext_lazy("key for text search", 'material'))
+        material_key = str(pgettext_lazy("key for text search", "material"))
         result = [
             ('{}="{}"'.format(material_key, str(iron_metal)), 1),
             ('{}="{}"'.format(material_key, str(not_iron_metal)), 0),
@@ -1093,67 +1144,67 @@ class FindSearchTest(FindInit, TestCase, SearchText):
         # operation with no associated find
         operation = create_operation(self.user, values={"year": 2017})
         c.get(reverse("pin", args=["operation", operation.pk]))
-        response = c.get(reverse('get-find'), {})  # empty search -> check pined
+        response = c.get(reverse("get-find"), {})  # empty search -> check pined
         self.assertEqual(response.status_code, 200)
         content = response.content.decode()
-        self.assertEqual(json.loads(content)['recordsTotal'], 0)
+        self.assertEqual(json.loads(content)["recordsTotal"], 0)
 
         # pinned operation with current find
         find = self.finds[0]
-        c.get(reverse(
-            "pin",
-            args=["operation",
-                  find.get_first_base_find().context_record.operation.pk]))
-        response = c.get(reverse('get-find'), {})  # empty search -> check pined
+        c.get(
+            reverse(
+                "pin",
+                args=[
+                    "operation",
+                    find.get_first_base_find().context_record.operation.pk,
+                ],
+            )
+        )
+        response = c.get(reverse("get-find"), {})  # empty search -> check pined
         self.assertEqual(response.status_code, 200)
         content = response.content.decode()
-        self.assertEqual(json.loads(content)['recordsTotal'], 1)
+        self.assertEqual(json.loads(content)["recordsTotal"], 1)
 
     def test_period_hierarchic_search(self):
         find = self.finds[0]
         c = Client()
 
-        neo = Period.objects.get(txt_idx='neolithic')
-        final_neo = Period.objects.get(txt_idx='final-neolithic')
-        recent_neo = Period.objects.get(txt_idx='recent-neolithic')
-        dating = Dating.objects.create(
-            period=final_neo
-        )
+        neo = Period.objects.get(txt_idx="neolithic")
+        final_neo = Period.objects.get(txt_idx="final-neolithic")
+        recent_neo = Period.objects.get(txt_idx="recent-neolithic")
+        dating = Dating.objects.create(period=final_neo)
         find.datings.add(dating)
         find = models.Find.objects.get(pk=find.pk)
         find.save()
 
-        search = {'datings__period': final_neo.pk}
+        search = {"datings__period": final_neo.pk}
 
         # no result when no authentication
-        response = c.get(reverse('get-find'), search)
+        response = c.get(reverse("get-find"), search)
         self.assertRedirects(response, "/")
 
         # one result for exact search
         c.login(username=self.username, password=self.password)
-        response = c.get(reverse('get-find'), search)
+        response = c.get(reverse("get-find"), search)
         self.assertEqual(response.status_code, 200)
         res = json.loads(response.content.decode())
-        self.assertEqual(res['recordsTotal'], 1)
-        self.assertEqual(res["rows"][0]["cached_periods"],
-                         str(final_neo))
+        self.assertEqual(res["recordsTotal"], 1)
+        self.assertEqual(res["rows"][0]["cached_periods"], str(final_neo))
 
         # no result for the brother
-        search = {'datings__period': recent_neo.pk}
-        response = c.get(reverse('get-find'), search)
+        search = {"datings__period": recent_neo.pk}
+        response = c.get(reverse("get-find"), search)
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(
-            json.loads(response.content.decode())['recordsTotal'], 0)
+        self.assertEqual(json.loads(response.content.decode())["recordsTotal"], 0)
 
         # one result for the father
-        search = {'datings__period': neo.pk}
-        response = c.get(reverse('get-find'), search)
+        search = {"datings__period": neo.pk}
+        response = c.get(reverse("get-find"), search)
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(
-            json.loads(response.content.decode())['recordsTotal'], 1)
+        self.assertEqual(json.loads(response.content.decode())["recordsTotal"], 1)
 
         # test on text search
-        period_key = str(pgettext_lazy("key for text search", 'datings-period'))
+        period_key = str(pgettext_lazy("key for text search", "datings-period"))
         result = [
             ('{}="{}"'.format(period_key, str(final_neo)), 1),
             ('{}="{}"'.format(period_key, str(recent_neo)), 0),
@@ -1176,36 +1227,36 @@ class FindSearchTest(FindInit, TestCase, SearchText):
         find.conservatory_state = cs2
         find.save()
 
-        search = {'search_vector': f'conservatory="{cs2.name}"'}
+        search = {"search_vector": f'conservatory="{cs2.name}"'}
 
         # no result when no authentication
-        response = c.get(reverse('get-find'), search)
+        response = c.get(reverse("get-find"), search)
         self.assertRedirects(response, "/")
 
         c.login(username=self.username, password=self.password)
 
         # one result for exact search
-        response = c.get(reverse('get-find'), search)
+        response = c.get(reverse("get-find"), search)
         self.assertEqual(response.status_code, 200)
         content = response.content.decode()
-        self.assertEqual(json.loads(content)['recordsTotal'], 1)
+        self.assertEqual(json.loads(content)["recordsTotal"], 1)
 
         # no result for the brother
-        search = {'search_vector': f'conservatory="{cs3.name}"'}
-        response = c.get(reverse('get-find'), search)
+        search = {"search_vector": f'conservatory="{cs3.name}"'}
+        response = c.get(reverse("get-find"), search)
         self.assertEqual(response.status_code, 200)
         content = response.content.decode()
-        self.assertEqual(json.loads(content)['recordsTotal'], 0)
+        self.assertEqual(json.loads(content)["recordsTotal"], 0)
 
         # one result for the father
-        search = {'search_vector': f'conservatory="{cs1.name}"'}
-        response = c.get(reverse('get-find'), search)
+        search = {"search_vector": f'conservatory="{cs1.name}"'}
+        response = c.get(reverse("get-find"), search)
         self.assertEqual(response.status_code, 200)
         content = response.content.decode()
-        self.assertEqual(json.loads(content)['recordsTotal'], 1)
+        self.assertEqual(json.loads(content)["recordsTotal"], 1)
 
         # test on text search
-        key = str(pgettext_lazy("key for text search", 'conservatory'))
+        key = str(pgettext_lazy("key for text search", "conservatory"))
         result = [
             ('{}="{}"'.format(key, str(cs2)), 1),
             ('{}="{}"'.format(key, str(cs3)), 0),
@@ -1216,27 +1267,30 @@ class FindSearchTest(FindInit, TestCase, SearchText):
     def test_image_search(self):
         c = Client()
         c.login(username=self.username, password=self.password)
-        search = {'documents__image__isnull': 2}  # 2 for nullboolfield is None
-        response = c.get(reverse('get-find'), search)
+        search = {"documents__image__isnull": 2}  # 2 for nullboolfield is None
+        response = c.get(reverse("get-find"), search)
         self.assertEqual(response.status_code, 200)
         res = json.loads(response.content.decode())
-        self.assertEqual(res['recordsTotal'], 0)
+        self.assertEqual(res["recordsTotal"], 0)
 
         # add an image to the first find
         document = Document.objects.create(title="Image!")
-        image_path = settings.ROOT_PATH + \
-              '../ishtar_common/static/media/images/ishtar-bg.jpg'
+        image_path = (
+            settings.ROOT_PATH + "../ishtar_common/static/media/images/ishtar-bg.jpg"
+        )
         document.image = SimpleUploadedFile(
-            name='ishtar-bg.jpg', content=open(image_path, 'rb').read(),
-            content_type='image/jpeg')
+            name="ishtar-bg.jpg",
+            content=open(image_path, "rb").read(),
+            content_type="image/jpeg",
+        )
         document.save()
 
         self.finds[0].documents.add(document)
         self.finds[0].save()
-        response = c.get(reverse('get-find'), search)
+        response = c.get(reverse("get-find"), search)
         self.assertEqual(response.status_code, 200)
         res = json.loads(response.content.decode())
-        self.assertEqual(res['recordsTotal'], 1)
+        self.assertEqual(res["recordsTotal"], 1)
 
     def test_search_with_callable(self):
         find = self.finds[0]
@@ -1244,21 +1298,21 @@ class FindSearchTest(FindInit, TestCase, SearchText):
         c = Client()
         c.login(username=self.username, password=self.password)
 
-        loan_key = str(pgettext_lazy("key for text search", 'loan'))
+        loan_key = str(pgettext_lazy("key for text search", "loan"))
 
         result = [
             ('{}="{}"'.format(loan_key, str(_("Yes"))), 0),
             ('{}="{}"'.format(loan_key, str(_("No"))), 0),
-            ]
+        ]
         self._test_search(c, result, context="No container defined")
 
         warehouse = Warehouse.objects.create(
-            name="Lambda warehouse",
-            warehouse_type=WarehouseType.objects.all()[0])
+            name="Lambda warehouse", warehouse_type=WarehouseType.objects.all()[0]
+        )
         container = Container.objects.create(
             location=warehouse,
             responsible=warehouse,
-            container_type=ContainerType.objects.all()[0]
+            container_type=ContainerType.objects.all()[0],
         )
         find.container_ref = container
         find.container = container
@@ -1266,7 +1320,7 @@ class FindSearchTest(FindInit, TestCase, SearchText):
         container2 = Container.objects.create(
             location=warehouse,
             responsible=warehouse,
-            container_type=ContainerType.objects.all()[0]
+            container_type=ContainerType.objects.all()[0],
         )
         find2.container_ref = container2
         find2.container = container2
@@ -1276,8 +1330,9 @@ class FindSearchTest(FindInit, TestCase, SearchText):
             ('{}="{}"'.format(loan_key, str(_("Yes"))), 0),
             ('{}="{}"'.format(loan_key, str(_("No"))), 2),
         ]
-        self._test_search(c, result, context="All container in their "
-                                             "reference location")
+        self._test_search(
+            c, result, context="All container in their " "reference location"
+        )
         find2.container = container
         find2.save()
 
@@ -1285,8 +1340,9 @@ class FindSearchTest(FindInit, TestCase, SearchText):
             ('{}="{}"'.format(loan_key, str(_("Yes"))), 1),
             ('{}="{}"'.format(loan_key, str(_("No"))), 1),
         ]
-        self._test_search(c, result, context="One container in his "
-                                             "reference location")
+        self._test_search(
+            c, result, context="One container in his " "reference location"
+        )
 
 
 class FindAutocompleteTest(FindInit, TestCase):
@@ -1298,10 +1354,9 @@ class FindAutocompleteTest(FindInit, TestCase):
         self.create_finds(force=True)
         self.create_finds(force=True)
         self.create_finds(force=True)
-        self.username = 'myuser'
-        self.password = 'mypassword'
-        User.objects.create_superuser(self.username, 'myemail@test.com',
-                                      self.password)
+        self.username = "myuser"
+        self.password = "mypassword"
+        User.objects.create_superuser(self.username, "myemail@test.com", self.password)
         self.client = Client()
 
     def test_autocomplete(self):
@@ -1319,14 +1374,14 @@ class FindAutocompleteTest(FindInit, TestCase):
         find4.save()
         c = Client()
         c.login(username=self.username, password=self.password)
-        response = c.get(reverse('autocomplete-find') + "?term=12")
+        response = c.get(reverse("autocomplete-find") + "?term=12")
         self.assertEqual(response.status_code, 200)
         content = response.content.decode()
         res = json.loads(content)
         self.assertEqual(len(res), 3)
-        self.assertEqual(res[0]['id'], find2.pk)  # " 12" - startswith
-        self.assertEqual(res[1]['id'], find.pk)  # 12 - endswith
-        self.assertEqual(res[2]['id'], find4.pk)  # 12 - contains
+        self.assertEqual(res[0]["id"], find2.pk)  # " 12" - startswith
+        self.assertEqual(res[1]["id"], find.pk)  # 12 - endswith
+        self.assertEqual(res[2]["id"], find4.pk)  # 12 - contains
 
 
 class FindPermissionTest(FindInit, TestCase):
@@ -1336,23 +1391,26 @@ class FindPermissionTest(FindInit, TestCase):
     def setUp(self):
         self.username, self.password, self.user = create_superuser()
         self.alt_username, self.alt_password, self.alt_user = create_user()
-        ct_find = ContentType.objects.get(app_label='archaeological_finds',
-                                          model='find')
-        self.alt_user.user_permissions.add(Permission.objects.get(
-            codename='view_own_find', content_type=ct_find))
-        self.alt_user.user_permissions.add(Permission.objects.get(
-            codename='change_own_find', content_type=ct_find))
+        ct_find = ContentType.objects.get(
+            app_label="archaeological_finds", model="find"
+        )
+        self.alt_user.user_permissions.add(
+            Permission.objects.get(codename="view_own_find", content_type=ct_find)
+        )
+        self.alt_user.user_permissions.add(
+            Permission.objects.get(codename="change_own_find", content_type=ct_find)
+        )
         self.alt_username2, self.alt_password2, self.alt_user2 = create_user(
-            username='luke', password='iamyourfather'
+            username="luke", password="iamyourfather"
         )
         profile = UserProfile.objects.create(
-            profile_type=ProfileType.objects.get(txt_idx='collaborator'),
+            profile_type=ProfileType.objects.get(txt_idx="collaborator"),
             person=self.alt_user2.ishtaruser.person,
-            current=True
+            current=True,
         )
 
-        town = Town.objects.create(name='Tatouine', numero_insee='66000')
-        area = Area.objects.create(label='Galaxie', txt_idx='galaxie')
+        town = Town.objects.create(name="Tatouine", numero_insee="66000")
+        area = Area.objects.create(label="Galaxie", txt_idx="galaxie")
         area.towns.add(town)
         profile.areas.add(area)
 
@@ -1361,18 +1419,20 @@ class FindPermissionTest(FindInit, TestCase):
         self.create_operation(self.alt_user, self.orgas[0])
 
         self.create_context_record(
-            user=self.user,
-            data={"label": "CR 1", "operation": self.operations[0]})
+            user=self.user, data={"label": "CR 1", "operation": self.operations[0]}
+        )
         self.create_context_record(
-            user=self.alt_user,
-            data={"label": "CR 2", "operation": self.operations[1]})
+            user=self.alt_user, data={"label": "CR 2", "operation": self.operations[1]}
+        )
         self.cr_1 = self.context_records[-2]
         self.cr_2 = self.context_records[-1]
 
-        self.create_finds(data_base={'context_record': self.cr_1},
-                          user=self.user, force=True)
-        self.create_finds(data_base={'context_record': self.cr_2},
-                          user=self.alt_user, force=True)
+        self.create_finds(
+            data_base={"context_record": self.cr_1}, user=self.user, force=True
+        )
+        self.create_finds(
+            data_base={"context_record": self.cr_2}, user=self.alt_user, force=True
+        )
 
         self.find_1 = self.finds[-2]
         self.find_2 = self.finds[-1]
@@ -1381,27 +1441,26 @@ class FindPermissionTest(FindInit, TestCase):
     def test_own_search(self):
         # no result when no authentification
         c = Client()
-        response = c.get(reverse('get-find'))
-        self.assertTrue(not response.content or
-                        not json.loads(response.content))
+        response = c.get(reverse("get-find"))
+        self.assertTrue(not response.content or not json.loads(response.content))
 
         # possession
         c = Client()
         c.login(username=self.alt_username, password=self.alt_password)
-        response = c.get(reverse('get-find'))
+        response = c.get(reverse("get-find"))
         # only one "own" context record available
         content = response.content.decode()
         self.assertTrue(json.loads(content))
-        self.assertEqual(json.loads(content)['recordsTotal'], 1)
+        self.assertEqual(json.loads(content)["recordsTotal"], 1)
 
         # area filter
         c = Client()
         c.login(username=self.alt_username2, password=self.alt_password2)
-        response = c.get(reverse('get-find'))
+        response = c.get(reverse("get-find"))
         # only one "own" operation available
         content = response.content.decode()
         self.assertTrue(json.loads(content))
-        self.assertEqual(json.loads(content)['recordsTotal'], 1)
+        self.assertEqual(json.loads(content)["recordsTotal"], 1)
 
 
 class FindQATest(FindInit, TestCase):
@@ -1413,17 +1472,16 @@ class FindQATest(FindInit, TestCase):
         self.create_finds(data_base={"label": "Find 2"}, force=True)
         self.username, self.password, self.user = create_superuser()
         self.alt_username, self.alt_password, self.alt_user = create_user()
-        self.alt_user.user_permissions.add(Permission.objects.get(
-            codename='change_find'))
+        self.alt_user.user_permissions.add(
+            Permission.objects.get(codename="change_find")
+        )
 
     def test_duplicate(self):
         t1, __ = models.Treatment.objects.get_or_create(
-            label="Treatment 1",
-            treatment_state=models.TreatmentState.objects.all()[0]
+            label="Treatment 1", treatment_state=models.TreatmentState.objects.all()[0]
         )
         t2, __ = models.Treatment.objects.get_or_create(
-            label="Treatment 1",
-            treatment_state=models.TreatmentState.objects.all()[0]
+            label="Treatment 1", treatment_state=models.TreatmentState.objects.all()[0]
         )
         find = self.finds[0]
         default_desc = "Description for duplicate"
@@ -1435,9 +1493,9 @@ class FindQATest(FindInit, TestCase):
         find.treatments.add(t2)
 
         c = Client()
-        url = reverse('find-qa-duplicate', args=[find.pk])
+        url = reverse("find-qa-duplicate", args=[find.pk])
         response = c.get(url)
-        self.assertRedirects(response, '/')
+        self.assertRedirects(response, "/")
 
         c = Client()
         c.login(username=self.username, password=self.password)
@@ -1449,19 +1507,16 @@ class FindQATest(FindInit, TestCase):
         response = c.get(url)
         self.assertEqual(response.status_code, 200)
 
-        data = {
-            "denomination": "clone",
-            "label": "clone - free id"
-        }
+        data = {"denomination": "clone", "label": "clone - free id"}
         nb_find = models.Find.objects.count()
         nb_bf = models.BaseFind.objects.count()
         response = c.post(url, data)
         self.assertEqual(response.status_code, 302)  # success redirect
         self.assertEqual(models.Find.objects.count(), nb_find + 1)
         self.assertEqual(models.BaseFind.objects.count(), nb_bf + 1)
-        new = models.Find.objects.order_by('-pk').all()[0]
+        new = models.Find.objects.order_by("-pk").all()[0]
         self.assertEqual(new.description, default_desc)
-        new_bf = models.BaseFind.objects.order_by('-pk').all()[0]
+        new_bf = models.BaseFind.objects.order_by("-pk").all()[0]
         base_bf = find.get_first_base_find()
         self.assertEqual(new_bf.context_record, base_bf.context_record)
         self.assertNotIn(d, list(new.documents.all()))
@@ -1473,17 +1528,17 @@ class FindQATest(FindInit, TestCase):
     def test_bulk_update(self):
         c = Client()
         pks = "{}-{}".format(self.finds[0].pk, self.finds[1].pk)
-        response = c.get(reverse('find-qa-bulk-update', args=[pks]))
-        self.assertRedirects(response, '/')
+        response = c.get(reverse("find-qa-bulk-update", args=[pks]))
+        self.assertRedirects(response, "/")
 
         c = Client()
         c.login(username=self.username, password=self.password)
-        response = c.get(reverse('find-qa-bulk-update', args=[pks]))
+        response = c.get(reverse("find-qa-bulk-update", args=[pks]))
         self.assertEqual(response.status_code, 200)
 
         c = Client()
         c.login(username=self.alt_username, password=self.alt_password)
-        response = c.get(reverse('find-qa-bulk-update', args=[pks]))
+        response = c.get(reverse("find-qa-bulk-update", args=[pks]))
         self.assertEqual(response.status_code, 200)
 
         find_0 = self.finds[0]
@@ -1496,51 +1551,45 @@ class FindQATest(FindInit, TestCase):
         find_1.save()
 
         period = Period.objects.all()[0].pk
-        self.assertNotIn(period,
-                         [dating.period.pk for dating in find_0.datings.all()])
-        self.assertNotIn(period,
-                         [dating.period.pk for dating in find_1.datings.all()])
+        self.assertNotIn(period, [dating.period.pk for dating in find_0.datings.all()])
+        self.assertNotIn(period, [dating.period.pk for dating in find_1.datings.all()])
         extra_desc = "Extra description"
         response = c.post(
-            reverse('find-qa-bulk-update-confirm', args=[pks]),
-            {'qa_period': period, 'qa_description': extra_desc}
+            reverse("find-qa-bulk-update-confirm", args=[pks]),
+            {"qa_period": period, "qa_description": extra_desc},
         )
         if response.status_code != 200:
-            self.assertRedirects(response, '/success/')
-        self.assertIn(period,
-                      [dating.period.pk for dating in find_0.datings.all()])
-        self.assertIn(period,
-                      [dating.period.pk for dating in find_1.datings.all()])
-        self.assertEqual(models.Find.objects.get(pk=find_0.pk).description,
-                         base_desc_0 + "\n" + extra_desc)
-        self.assertEqual(models.Find.objects.get(pk=find_1.pk).description,
-                         base_desc_1 + "\n" + extra_desc)
+            self.assertRedirects(response, "/success/")
+        self.assertIn(period, [dating.period.pk for dating in find_0.datings.all()])
+        self.assertIn(period, [dating.period.pk for dating in find_1.datings.all()])
+        self.assertEqual(
+            models.Find.objects.get(pk=find_0.pk).description,
+            base_desc_0 + "\n" + extra_desc,
+        )
+        self.assertEqual(
+            models.Find.objects.get(pk=find_1.pk).description,
+            base_desc_1 + "\n" + extra_desc,
+        )
 
     def test_basket(self):
         find_0 = self.finds[0]
         find_1 = self.finds[1]
         nb_basket = models.FindBasket.objects.count()
-        url = reverse('find-qa-basket', args=[find_0.pk])
+        url = reverse("find-qa-basket", args=[find_0.pk])
         c = Client()
         response = c.get(url)
-        self.assertRedirects(response, '/')
+        self.assertRedirects(response, "/")
 
         c.login(username=self.username, password=self.password)
         response = c.get(url)
         self.assertEqual(response.status_code, 200)
         label = "Test - basket"
-        data = {
-            "qa_bf_create_or_update": "create",
-            "qa_bf_label": label
-        }
+        data = {"qa_bf_create_or_update": "create", "qa_bf_label": label}
         response = c.post(url, data)
         if response.status_code != 200:
-            self.assertRedirects(response, '/success/')
-        self.assertEqual(
-            nb_basket + 1,
-            models.FindBasket.objects.count())
-        q = models.FindBasket.objects.filter(
-            user=self.user.ishtaruser, label=label)
+            self.assertRedirects(response, "/success/")
+        self.assertEqual(nb_basket + 1, models.FindBasket.objects.count())
+        q = models.FindBasket.objects.filter(user=self.user.ishtaruser, label=label)
         self.assertEqual(q.count(), 1)
         # no duplicate with same user, same name
         c.post(url, data)
@@ -1549,12 +1598,9 @@ class FindQATest(FindInit, TestCase):
         self.assertEqual(basket.items.count(), 1)
 
         # update
-        url = reverse('find-qa-basket', args=[find_1.pk])
+        url = reverse("find-qa-basket", args=[find_1.pk])
         self.assertEqual(basket.items.count(), 1)
-        data = {
-            "qa_bf_create_or_update": "update",
-            "qa_bf_basket": basket.pk
-        }
+        data = {"qa_bf_create_or_update": "update", "qa_bf_basket": basket.pk}
         c.post(url, data)
         self.assertEqual(basket.items.count(), 2)
         self.assertIn(find_1, list(basket.items.all()))
@@ -1578,11 +1624,12 @@ class FindQATest(FindInit, TestCase):
         find_0 = self.finds[0]
         find_1 = self.finds[1]
         pks = "{}-{}".format(find_0.pk, find_1.pk)
-        url = reverse('find-qa-packaging', args=[pks])
+        url = reverse("find-qa-packaging", args=[pks])
         response = c.get(url)
-        self.assertRedirects(response, '/')
+        self.assertRedirects(response, "/")
         profile, created = IshtarSiteProfile.objects.get_or_create(
-            slug='default', active=True)
+            slug="default", active=True
+        )
         profile.warehouse = False
         profile.save()
 
@@ -1603,60 +1650,61 @@ class FindQATest(FindInit, TestCase):
         self.assertEqual(response.status_code, 200)
 
         main_warehouse = Warehouse.objects.create(
-            name="Main",
-            warehouse_type=WarehouseType.objects.all()[0]
+            name="Main", warehouse_type=WarehouseType.objects.all()[0]
         )
 
         container = Container.objects.create(
-            reference="Test", responsible=main_warehouse,
+            reference="Test",
+            responsible=main_warehouse,
             location=main_warehouse,
-            container_type=ContainerType.objects.all()[0]
+            container_type=ContainerType.objects.all()[0],
         )
         container2 = Container.objects.create(
-            reference="Test2", responsible=main_warehouse,
+            reference="Test2",
+            responsible=main_warehouse,
             location=main_warehouse,
-            container_type=ContainerType.objects.all()[0]
+            container_type=ContainerType.objects.all()[0],
         )
-        packaging = models.TreatmentType.objects.get(txt_idx='packaging')
+        packaging = models.TreatmentType.objects.get(txt_idx="packaging")
         packaging.change_reference_location = True
         packaging.save()
 
         data_check_lst = [
-            ({
-                 'qa-packaging-container': container.pk,
-                 'qa-packaging-container_to_change': 'reference',
-             },
-             {
-                 'container_ref': container,
-                 'container': None
-             }, 0),
-            ({
-                 'qa-packaging-container': container2.pk,
-                 'qa-packaging-container_to_change': 'current',
-             },
-             {
-                 'container_ref': None,
-                 'container': container2
-             }, 0),
-            ({
-                 'qa-packaging-container': container.pk,
-                 'qa-packaging-container_to_change': 'current-and-reference',
-             },
-             {
-                 'container_ref': container,
-                 'container': container
-             }, 0),
-            ({
-                 'qa-packaging-container': container2.pk,
-                 'qa-packaging-container_to_change': 'reference',
-                 'qa-packaging-create_treatment': True,
-                 'qa-packaging-year': 2019,
-                 'qa-packaging-treatment_type': packaging.pk
-             },
-             {
-                 'container_ref': container2,
-                 'container': None
-             }, 1),
+            (
+                {
+                    "qa-packaging-container": container.pk,
+                    "qa-packaging-container_to_change": "reference",
+                },
+                {"container_ref": container, "container": None},
+                0,
+            ),
+            (
+                {
+                    "qa-packaging-container": container2.pk,
+                    "qa-packaging-container_to_change": "current",
+                },
+                {"container_ref": None, "container": container2},
+                0,
+            ),
+            (
+                {
+                    "qa-packaging-container": container.pk,
+                    "qa-packaging-container_to_change": "current-and-reference",
+                },
+                {"container_ref": container, "container": container},
+                0,
+            ),
+            (
+                {
+                    "qa-packaging-container": container2.pk,
+                    "qa-packaging-container_to_change": "reference",
+                    "qa-packaging-create_treatment": True,
+                    "qa-packaging-year": 2019,
+                    "qa-packaging-treatment_type": packaging.pk,
+                },
+                {"container_ref": container2, "container": None},
+                1,
+            ),
         ]
 
         for data, check, nb_treat in data_check_lst:
@@ -1670,10 +1718,8 @@ class FindQATest(FindInit, TestCase):
 
             init_nb_treat = models.Treatment.objects.count()
 
-            response = c.post(
-                reverse('find-qa-packaging', args=[pks]),
-                data)
-            self.assertRedirects(response, '/success/')
+            response = c.post(reverse("find-qa-packaging", args=[pks]), data)
+            self.assertRedirects(response, "/success/")
             for k in check:
                 find = models.Find.objects.get(pk=find_0.pk)
                 self.assertEqual(getattr(find, k), check[k])
@@ -1696,31 +1742,29 @@ class FindHistoryTest(FindInit, TestCase):
 
     def _add_datings(self, find):
         d1_attrs = {
-            "period": Period.objects.get(txt_idx='neolithic'),
+            "period": Period.objects.get(txt_idx="neolithic"),
             "start_date": 5000,
-            'end_date': 5001,
-            'dating_type': DatingType.objects.get(
-                txt_idx='from_absolute_dating'),
-            "quality": DatingQuality.objects.get(txt_idx='sure'),
-            "precise_dating": "Blah !!!"
+            "end_date": 5001,
+            "dating_type": DatingType.objects.get(txt_idx="from_absolute_dating"),
+            "quality": DatingQuality.objects.get(txt_idx="sure"),
+            "precise_dating": "Blah !!!",
         }
         d1 = Dating.objects.create(**d1_attrs)
         d2_attrs = {
-            "period": Period.objects.get(txt_idx='paleolithic'),
+            "period": Period.objects.get(txt_idx="paleolithic"),
         }
         d2 = Dating.objects.create(**d2_attrs)
 
         d1_dct, d2_dct = {}, {}
         for k in Dating.HISTORY_ATTR:
-            for dct, attr in ((d1_dct, d1_attrs) ,
-                              (d2_dct, d2_attrs)):
+            for dct, attr in ((d1_dct, d1_attrs), (d2_dct, d2_attrs)):
                 if k in attr:
-                    if hasattr(attr[k], 'txt_idx'):
+                    if hasattr(attr[k], "txt_idx"):
                         dct[k] = attr[k].txt_idx
                     else:
                         dct[k] = str(attr[k])
                 else:
-                    dct[k] = ''
+                    dct[k] = ""
 
         find.datings.add(d1)
         find.datings.add(d2)
@@ -1730,8 +1774,8 @@ class FindHistoryTest(FindInit, TestCase):
         find = self.finds[0]
         user = self.get_default_user()
 
-        ceram = models.MaterialType.objects.get(txt_idx='ceramic').pk
-        glass = models.MaterialType.objects.get(txt_idx='glass').pk
+        ceram = models.MaterialType.objects.get(txt_idx="ceramic").pk
+        glass = models.MaterialType.objects.get(txt_idx="glass").pk
 
         find = models.Find.objects.get(pk=find.pk)
         nb_hist = find.history.count()
@@ -1745,49 +1789,50 @@ class FindHistoryTest(FindInit, TestCase):
 
         find = models.Find.objects.get(pk=find.pk)
         self.assertIsNotNone(find.history_m2m)
-        self.assertIn('material_types', find.history_m2m)
+        self.assertIn("material_types", find.history_m2m)
         self.assertIn(
-            find.history_m2m['material_types'],
-            [['ceramic', 'glass'],   # order do not
-             ['glass', 'ceramic']])  # matter
-        self.assertIn('datings', find.history_m2m)
+            find.history_m2m["material_types"],
+            [["ceramic", "glass"], ["glass", "ceramic"]],  # order do not
+        )  # matter
+        self.assertIn("datings", find.history_m2m)
         self.assertIn(
-            find.history_m2m['datings'],
-            [[d1_txt, d2_txt],   # order do not
-             [d2_txt, d1_txt]])  # matter
+            find.history_m2m["datings"],
+            [[d1_txt, d2_txt], [d2_txt, d1_txt]],  # order do not
+        )  # matter
         self.assertEqual(find.history.count(), nb_hist + 1)
 
-        historical_material_types = find.history_m2m['material_types']
+        historical_material_types = find.history_m2m["material_types"]
 
         find = models.Find.objects.get(pk=find.pk)
         find.label = "hop hop hop2"
         find.history_modifier = user
-        if hasattr(find, 'skip_history_when_saving'):
-            delattr(find, 'skip_history_when_saving')
+        if hasattr(find, "skip_history_when_saving"):
+            delattr(find, "skip_history_when_saving")
         find._force_history = True
         find.save()
         find.material_types.remove(ceram)
         find.datings.clear()
 
         find = models.Find.objects.get(pk=find.pk)
-        self.assertEqual(find.history_m2m['material_types'], ['glass'])
-        self.assertEqual(find.history_m2m['datings'], [])
+        self.assertEqual(find.history_m2m["material_types"], ["glass"])
+        self.assertEqual(find.history_m2m["datings"], [])
         self.assertEqual(find.history.count(), nb_hist + 2)
-        self.assertEqual(find.history.all()[1].history_m2m['material_types'],
-                         historical_material_types)
-        self.assertEqual(find.history.all()[0].history_m2m['material_types'],
-                         ["glass"])
+        self.assertEqual(
+            find.history.all()[1].history_m2m["material_types"],
+            historical_material_types,
+        )
+        self.assertEqual(find.history.all()[0].history_m2m["material_types"], ["glass"])
 
     def _init_m2m(self, find, user):
-        ceram = models.MaterialType.objects.get(txt_idx='ceramic').pk
-        glass = models.MaterialType.objects.get(txt_idx='glass').pk
+        ceram = models.MaterialType.objects.get(txt_idx="ceramic").pk
+        glass = models.MaterialType.objects.get(txt_idx="glass").pk
 
         find = models.Find.objects.get(pk=find.pk)
         find.history_modifier = user
         find.label = "hop hop hop1"
         find._force_history = True
-        if hasattr(find, 'skip_history_when_saving'):
-            delattr(find, 'skip_history_when_saving')
+        if hasattr(find, "skip_history_when_saving"):
+            delattr(find, "skip_history_when_saving")
         find.save()
         find.material_types.add(ceram)
         find.material_types.add(glass)
@@ -1797,8 +1842,8 @@ class FindHistoryTest(FindInit, TestCase):
         find.history_modifier = user
         find.label = "hop hop hop2"
         find._force_history = True
-        if hasattr(find, 'skip_history_when_saving'):
-            delattr(find, 'skip_history_when_saving')
+        if hasattr(find, "skip_history_when_saving"):
+            delattr(find, "skip_history_when_saving")
         find.save()
         find.datings.clear()
         find.material_types.remove(ceram)
@@ -1810,32 +1855,35 @@ class FindHistoryTest(FindInit, TestCase):
         self._init_m2m(find, user)
 
         find = models.Find.objects.get(pk=find.pk)
-        history_date = find.history.order_by('-history_date').all()[
-            1].history_date.strftime('%Y-%m-%dT%H:%M:%S.%f')
+        history_date = (
+            find.history.order_by("-history_date")
+            .all()[1]
+            .history_date.strftime("%Y-%m-%dT%H:%M:%S.%f")
+        )
 
         c.login(username=self.username, password=self.password)
-        response = c.get(reverse('show-find',
-                                 kwargs={'pk': find.pk}))
+        response = c.get(reverse("show-find", kwargs={"pk": find.pk}))
         self.assertEqual(response.status_code, 200)
         self.assertIn(b'class="card sheet"', response.content)
-        content = response.content.decode('utf-8')
-        self.assertNotIn(
-            Period.objects.get(txt_idx='neolithic').label, content)
+        content = response.content.decode("utf-8")
+        self.assertNotIn(Period.objects.get(txt_idx="neolithic").label, content)
         self.assertNotIn("5001", content)
 
-        response = c.get(reverse('show-historized-find',
-                                 kwargs={'pk': find.pk,
-                                         'date': history_date}))
+        response = c.get(
+            reverse(
+                "show-historized-find", kwargs={"pk": find.pk, "date": history_date}
+            )
+        )
         self.assertEqual(response.status_code, 200)
-        content = response.content.decode('utf-8')
+        content = response.content.decode("utf-8")
         self.assertIn('class="card sheet"', content)
         self.assertIn(
-            models.MaterialType.objects.get(txt_idx='ceramic').label, content,
-            msg="ceramic not found in historical sheet")
-        self.assertIn("5001", content, msg="5001 not found in historical "
-                                           "sheet")
-        self.assertIn(
-            Period.objects.get(txt_idx='neolithic').label, content)
+            models.MaterialType.objects.get(txt_idx="ceramic").label,
+            content,
+            msg="ceramic not found in historical sheet",
+        )
+        self.assertIn("5001", content, msg="5001 not found in historical " "sheet")
+        self.assertIn(Period.objects.get(txt_idx="neolithic").label, content)
 
     def test_m2m_history_restore(self):
         user = self.get_default_user()
@@ -1843,16 +1891,15 @@ class FindHistoryTest(FindInit, TestCase):
         self._init_m2m(find, user)
 
         find = models.Find.objects.get(pk=find.pk)
-        ceram = models.MaterialType.objects.get(txt_idx='ceramic')
-        glass = models.MaterialType.objects.get(txt_idx='glass')
+        ceram = models.MaterialType.objects.get(txt_idx="ceramic")
+        glass = models.MaterialType.objects.get(txt_idx="glass")
 
         materials = list(find.material_types.all())
         self.assertNotIn(ceram, materials)
         self.assertIn(glass, materials)
         self.assertEqual(list(find.datings.all()), [])
 
-        history_date = find.history.order_by('-history_date').all()[
-            1].history_date
+        history_date = find.history.order_by("-history_date").all()[1].history_date
         find.rollback(history_date)
 
         find = models.Find.objects.get(pk=find.pk)
@@ -1865,10 +1912,10 @@ class FindHistoryTest(FindInit, TestCase):
             dating_dct = {}
             for k in self.d1_dct.keys():
                 if not getattr(dating, k):
-                    dating_dct[k] = ''
+                    dating_dct[k] = ""
                     continue
                 dating_dct[k] = getattr(dating, k)
-                if hasattr(dating_dct[k], 'txt_idx'):
+                if hasattr(dating_dct[k], "txt_idx"):
                     dating_dct[k] = dating_dct[k].txt_idx
                 dating_dct[k] = str(dating_dct[k])
 
@@ -1883,31 +1930,34 @@ class TreatmentTest(FindInit, TestCase):
     model = models.Find
 
     def setUp(self):
-        base_img = settings.ROOT_PATH + \
-            '../ishtar_common/static/media/images/ishtar-bg.jpg'
+        base_img = (
+            settings.ROOT_PATH + "../ishtar_common/static/media/images/ishtar-bg.jpg"
+        )
         temp_dir = tempfile.gettempdir()
-        img = os.path.join(temp_dir, 'ishtar-bg.jpg')
+        img = os.path.join(temp_dir, "ishtar-bg.jpg")
         shutil.copy2(base_img, img)
 
         self.create_finds(data_base={"label": "Find 1"}, force=True)
         self.create_finds(data_base={"label": "Find 2"}, force=True)
         image = Document.objects.create(title="Image!")
-        image.image.save('ishtar-bg.jpg', File(open(img, "rb")))
+        image.image.save("ishtar-bg.jpg", File(open(img, "rb")))
         self.finds[0].documents.add(image)
         self.finds[0].save()
 
         self.basket = models.FindBasket.objects.create(
-            label="My basket", user=IshtarUser.objects.get(
-                pk=self.get_default_user().pk))
+            label="My basket",
+            user=IshtarUser.objects.get(pk=self.get_default_user().pk),
+        )
         self.other_basket = models.FindBasket.objects.create(
-            label="My other basket", user=IshtarUser.objects.get(
-                pk=self.get_default_user().pk))
+            label="My other basket",
+            user=IshtarUser.objects.get(pk=self.get_default_user().pk),
+        )
         for find in self.finds:
             self.basket.items.add(find)
             self.other_basket.items.add(find)
 
     def test_packaging_with_new_find_creation(self):
-        treatment_type = models.TreatmentType.objects.get(txt_idx='packaging')
+        treatment_type = models.TreatmentType.objects.get(txt_idx="packaging")
         # make packaging a treatment with a new version of the find created
         treatment_type.create_new_find = True
         treatment_type.save()
@@ -1918,45 +1968,52 @@ class TreatmentTest(FindInit, TestCase):
         first_find = self.finds[0]
 
         completed, created = models.TreatmentState.objects.get_or_create(
-            txt_idx='completed', defaults={"executed": True, "label": "Done"}
+            txt_idx="completed", defaults={"executed": True, "label": "Done"}
         )
         completed.executed = True
         completed.save()
 
         treatment.treatment_state = completed
         treatment.save(
-            user=self.get_default_user(), items=self.basket,
+            user=self.get_default_user(),
+            items=self.basket,
             treatment_type_list=[treatment_type],
         )
         treatment.treatment_types.add(treatment_type)
 
-        self.assertEqual(items_nb + self.basket.items.count(),
-                         models.Find.objects.count(),
-                         msg="Packaging doesn't generate enough new finds")
+        self.assertEqual(
+            items_nb + self.basket.items.count(),
+            models.Find.objects.count(),
+            msg="Packaging doesn't generate enough new finds",
+        )
 
         resulting_find = models.Find.objects.get(
             upstream_treatment__upstream=first_find,
-            base_finds__pk=first_find.base_finds.all()[0].pk
+            base_finds__pk=first_find.base_finds.all()[0].pk,
         )
 
         # image names used to be altered on save: check for this bug
         self.assertEqual(
             resulting_find.documents.all()[0].title,
-            models.Find.objects.get(pk=first_find.pk).documents.all()[0].title
+            models.Find.objects.get(pk=first_find.pk).documents.all()[0].title,
         )
 
         # new version of the find is in the basket
         for item in self.basket.items.all():
             self.assertNotIn(
-                item, self.finds,
-                msg="Original basket have not been upgraded after packaging")
+                item,
+                self.finds,
+                msg="Original basket have not been upgraded after packaging",
+            )
         for item in self.other_basket.items.all():
             self.assertNotIn(
-                item, self.finds,
-                msg="Other basket have not been upgraded after packaging")
+                item,
+                self.finds,
+                msg="Other basket have not been upgraded after packaging",
+            )
 
     def test_simple_delete(self):
-        treatment_type = models.TreatmentType.objects.get(txt_idx='packaging')
+        treatment_type = models.TreatmentType.objects.get(txt_idx="packaging")
         treatment_type.create_new_find = False
         treatment_type.save()
 
@@ -1966,14 +2023,15 @@ class TreatmentTest(FindInit, TestCase):
 
         initial_find = self.finds[0]
         completed, created = models.TreatmentState.objects.get_or_create(
-            txt_idx='completed', defaults={"executed": True, "label": "Done"}
+            txt_idx="completed", defaults={"executed": True, "label": "Done"}
         )
         completed.executed = True
         completed.save()
 
         treatment.treatment_state = completed
         treatment.save(
-            user=self.get_default_user(), items=self.basket,
+            user=self.get_default_user(),
+            items=self.basket,
             treatment_type_list=[treatment_type],
         )
         treatment.treatment_types.add(treatment_type)
@@ -1981,8 +2039,7 @@ class TreatmentTest(FindInit, TestCase):
         self.assertEqual(nb_find, models.Find.objects.count())
 
         treatment.delete()
-        self.assertEqual(
-            models.Treatment.objects.filter(pk=treatment.pk).count(), 0)
+        self.assertEqual(models.Treatment.objects.filter(pk=treatment.pk).count(), 0)
 
         q = models.Find.objects.filter(pk=initial_find.pk)
         # initial find not deleted
@@ -1991,7 +2048,7 @@ class TreatmentTest(FindInit, TestCase):
         self.assertEqual(initial_find.upstream_treatment, None)
 
     def test_upstream_find_delete(self):
-        treatment_type = models.TreatmentType.objects.get(txt_idx='packaging')
+        treatment_type = models.TreatmentType.objects.get(txt_idx="packaging")
         # make packaging a treatment with a new version of the find created
         treatment_type.create_new_find = True
         treatment_type.save()
@@ -2002,30 +2059,29 @@ class TreatmentTest(FindInit, TestCase):
 
         initial_find = self.finds[0]
         completed, created = models.TreatmentState.objects.get_or_create(
-            txt_idx='completed', defaults={"executed": True, "label": "Done"}
+            txt_idx="completed", defaults={"executed": True, "label": "Done"}
         )
         completed.executed = True
         completed.save()
 
         treatment.treatment_state = completed
         treatment.save(
-            user=self.get_default_user(), items=self.basket,
+            user=self.get_default_user(),
+            items=self.basket,
             treatment_type_list=[treatment_type],
         )
         treatment.treatment_types.add(treatment_type)
 
         nb_b = self.basket.items.count()
-        self.assertEqual(
-            nb_find + nb_b, models.Find.objects.count())
+        self.assertEqual(nb_find + nb_b, models.Find.objects.count())
 
         resulting_find = models.Find.objects.get(
             upstream_treatment__upstream=initial_find,
-            base_finds__pk=initial_find.base_finds.all()[0].pk
+            base_finds__pk=initial_find.base_finds.all()[0].pk,
         )
         resulting_find.delete()
 
-        self.assertEqual(
-            models.Treatment.objects.filter(pk=treatment.pk).count(), 0)
+        self.assertEqual(models.Treatment.objects.filter(pk=treatment.pk).count(), 0)
         q = models.Find.objects.filter(pk=initial_find.pk)
         # initial find not deleted
         self.assertEqual(q.count(), 1)
@@ -2033,7 +2089,7 @@ class TreatmentTest(FindInit, TestCase):
         self.assertEqual(initial_find.upstream_treatment, None)
 
     def test_treatment_delete(self):
-        treatment_type = models.TreatmentType.objects.get(txt_idx='packaging')
+        treatment_type = models.TreatmentType.objects.get(txt_idx="packaging")
         treatment_type.create_new_find = True
         treatment_type.save()
 
@@ -2043,28 +2099,27 @@ class TreatmentTest(FindInit, TestCase):
 
         initial_find = self.finds[0]
         completed, created = models.TreatmentState.objects.get_or_create(
-            txt_idx='completed', defaults={"executed": True, "label": "Done"}
+            txt_idx="completed", defaults={"executed": True, "label": "Done"}
         )
         completed.executed = True
         completed.save()
 
         treatment.treatment_state = completed
         treatment.save(
-            user=self.get_default_user(), items=self.basket,
+            user=self.get_default_user(),
+            items=self.basket,
             treatment_type_list=[treatment_type],
         )
         treatment.treatment_types.add(treatment_type)
 
         nb_b = self.basket.items.count()
-        self.assertEqual(
-            nb_find + nb_b, models.Find.objects.count())
+        self.assertEqual(nb_find + nb_b, models.Find.objects.count())
 
         treatment.delete()
 
         self.assertEqual(nb_find, models.Find.objects.count())
 
-        self.assertEqual(
-            models.Treatment.objects.filter(pk=treatment.pk).count(), 0)
+        self.assertEqual(models.Treatment.objects.filter(pk=treatment.pk).count(), 0)
         q = models.Find.objects.filter(pk=initial_find.pk)
         # initial find not deleted
         self.assertEqual(q.count(), 1)
@@ -2081,12 +2136,12 @@ class GeomaticTest(FindInit, TestCase):
         self.create_finds(data_base={"label": "Find 1"}, force=True)
 
     def test_point_precision(self):
-        self.username = 'myuser'
-        self.password = 'mypassword'
-        User.objects.create_superuser(self.username, 'myemail@test.com',
-                                      self.password)
+        self.username = "myuser"
+        self.password = "mypassword"
+        User.objects.create_superuser(self.username, "myemail@test.com", self.password)
         profile, created = IshtarSiteProfile.objects.get_or_create(
-            slug='default', active=True)
+            slug="default", active=True
+        )
         profile.mapping = True
         profile.save()
         wgs84 = SpatialReferenceSystem.objects.get(srid=4326)
@@ -2101,19 +2156,18 @@ class GeomaticTest(FindInit, TestCase):
         find = base_find.find.all()[0]
         c = Client()
         c.login(username=self.username, password=self.password)
-        response = c.get(
-            reverse('show-find', kwargs={'pk': find.pk}))
-        self.assertIn(b'33.12999', response.content)
+        response = c.get(reverse("show-find", kwargs={"pk": find.pk}))
+        self.assertIn(b"33.12999", response.content)
         profile.point_precision = 2
         profile.save()
 
-        response = c.get(
-            reverse('show-find', kwargs={'pk': find.pk}))
-        self.assertIn(b'33.13', response.content)
+        response = c.get(reverse("show-find", kwargs={"pk": find.pk}))
+        self.assertIn(b"33.13", response.content)
 
     def test_update_container_localisation_on_warehouse_update(self):
         profile, created = IshtarSiteProfile.objects.get_or_create(
-            slug='default', active=True)
+            slug="default", active=True
+        )
         profile.mapping = True
         profile.save()
         wgs84 = SpatialReferenceSystem.objects.get(srid=4326)
@@ -2122,17 +2176,15 @@ class GeomaticTest(FindInit, TestCase):
         base_find = find.base_finds.all()[0]
         self.assertEqual(base_find.x, None)
 
-        operation = Operation.objects.get(
-            pk=base_find.context_record.operation.pk
-        )
+        operation = Operation.objects.get(pk=base_find.context_record.operation.pk)
         operation.x, operation.y = 33, 42
         operation.spatial_reference_system = wgs84
         operation.save()
 
         # an update is pending for the linked context record
         q = ContextRecord.objects.filter(
-            pk=base_find.context_record.pk,
-            need_update=True)
+            pk=base_find.context_record.pk, need_update=True
+        )
         self.assertEqual(q.count(), 1)
 
         # process pending update
@@ -2163,15 +2215,15 @@ class GeomaticTest(FindInit, TestCase):
         base_find = find.base_finds.all()[0]
 
         srs, __ = SpatialReferenceSystem.objects.get_or_create(
-            txt_idx='wgs84', defaults={"srid": 4326, "label": 'WGS84',
-                                       'auth_name': 'EPSG'}
+            txt_idx="wgs84",
+            defaults={"srid": 4326, "label": "WGS84", "auth_name": "EPSG"},
         )
         profile = get_current_profile()
         profile.mapping = True
         profile.save()
 
         # db source
-        geom = GEOSGeometry('POINT({} {} {})'.format(2, 43, 1), srid=4326)
+        geom = GEOSGeometry("POINT({} {} {})".format(2, 43, 1), srid=4326)
         base_find.point = geom
         base_find.save()
         base_find = models.BaseFind.objects.get(pk=base_find.pk)
@@ -2180,9 +2232,10 @@ class GeomaticTest(FindInit, TestCase):
         self.assertIsNotNone(base_find.x)
         self.assertIsNotNone(base_find.y)
         self.assertIsNotNone(base_find.z)
-        self.assertEqual(base_find.point_source, 'P')  # precise
-        self.assertEqual(base_find.point_source_item,
-                         str(models.BaseFind._meta.verbose_name))
+        self.assertEqual(base_find.point_source, "P")  # precise
+        self.assertEqual(
+            base_find.point_source_item, str(models.BaseFind._meta.verbose_name)
+        )
 
         # re-save do not change sources
         base_find.save()
@@ -2192,9 +2245,10 @@ class GeomaticTest(FindInit, TestCase):
         self.assertIsNotNone(base_find.x)
         self.assertIsNotNone(base_find.y)
         self.assertIsNotNone(base_find.z)
-        self.assertEqual(base_find.point_source, 'P')  # precise
-        self.assertEqual(base_find.point_source_item,
-                         str(models.BaseFind._meta.verbose_name))
+        self.assertEqual(base_find.point_source, "P")  # precise
+        self.assertEqual(
+            base_find.point_source_item, str(models.BaseFind._meta.verbose_name)
+        )
 
         # form input
         base_find.x = 2
@@ -2205,17 +2259,19 @@ class GeomaticTest(FindInit, TestCase):
         base_find = models.BaseFind.objects.get(pk=base_find.pk)
         self.assertIsNotNone(base_find.point_2d)
         self.assertIsNotNone(base_find.point)
-        self.assertEqual(base_find.point_source, 'P')  # precise
-        self.assertEqual(base_find.point_source_item,
-                         str(models.BaseFind._meta.verbose_name))
+        self.assertEqual(base_find.point_source, "P")  # precise
+        self.assertEqual(
+            base_find.point_source_item, str(models.BaseFind._meta.verbose_name)
+        )
         # re-save do not change sources
         base_find.save()
         base_find = models.BaseFind.objects.get(pk=base_find.pk)
         self.assertIsNotNone(base_find.point_2d)
         self.assertIsNotNone(base_find.point)
-        self.assertEqual(base_find.point_source, 'P')  # precise
-        self.assertEqual(base_find.point_source_item,
-                         str(models.BaseFind._meta.verbose_name))
+        self.assertEqual(base_find.point_source, "P")  # precise
+        self.assertEqual(
+            base_find.point_source_item, str(models.BaseFind._meta.verbose_name)
+        )
 
         # reinit
         base_find.x = None
@@ -2229,18 +2285,21 @@ class GeomaticTest(FindInit, TestCase):
         self.assertEqual(base_find.point_source_item, None)
 
         profile, created = IshtarSiteProfile.objects.get_or_create(
-            slug='default', active=True)
+            slug="default", active=True
+        )
         profile.use_town_for_geo = True
         profile.save()
 
         # geom from context record town
-        center = 'POINT(6 10)'
-        limit = 'MULTIPOLYGON(((1 1,5 1,5 5,1 5,1 1),(2 2,2 3,3 3,3 2,2 2)),'\
-                '((6 3,9 2,9 4,6 3)))'
+        center = "POINT(6 10)"
+        limit = (
+            "MULTIPOLYGON(((1 1,5 1,5 5,1 5,1 1),(2 2,2 3,3 3,3 2,2 2)),"
+            "((6 3,9 2,9 4,6 3)))"
+        )
         cr = ContextRecord.objects.get(pk=base_find.context_record.pk)
         t = cr.town
-        t.center = 'SRID=4326;' + center
-        t.limit = 'SRID=4326;' + limit
+        t.center = "SRID=4326;" + center
+        t.limit = "SRID=4326;" + limit
         t.save()
         cr = ContextRecord.objects.get(pk=base_find.context_record.pk)
         base_find = models.BaseFind.objects.get(pk=base_find.pk)
@@ -2252,9 +2311,10 @@ class GeomaticTest(FindInit, TestCase):
         tp.transform(4326)
         self.assertLess(bfp.distance(tp), 0.0001)
         self.assertEqual(base_find.multi_polygon, cr.town.limit)
-        self.assertEqual(base_find.point_source, 'T')  # town
-        self.assertEqual(base_find.point_source_item,
-                         str(ContextRecord._meta.verbose_name))
+        self.assertEqual(base_find.point_source, "T")  # town
+        self.assertEqual(
+            base_find.point_source_item, str(ContextRecord._meta.verbose_name)
+        )
         # re-save do not change sources
         base_find.save()
         base_find = models.BaseFind.objects.get(pk=base_find.pk)
@@ -2264,15 +2324,16 @@ class GeomaticTest(FindInit, TestCase):
         tp.transform(4326)
         self.assertTrue(bfp.distance(tp) < 0.0001)
         self.assertEqual(base_find.multi_polygon, cr.town.limit)
-        self.assertEqual(base_find.point_source, 'T')  # town
-        self.assertEqual(base_find.point_source_item,
-                         str(ContextRecord._meta.verbose_name))
+        self.assertEqual(base_find.point_source, "T")  # town
+        self.assertEqual(
+            base_find.point_source_item, str(ContextRecord._meta.verbose_name)
+        )
 
         # geom from context record
-        center = 'POINT(8 6)'
+        center = "POINT(8 6)"
         cr = ContextRecord.objects.get(pk=base_find.context_record.pk)
-        cr.point_2d = 'SRID=4326;' + center
-        cr.point_source = 'P'
+        cr.point_2d = "SRID=4326;" + center
+        cr.point_source = "P"
         cr.point_source_item = str(ContextRecord._meta.verbose_name)
         cr.save()
         cr = ContextRecord.objects.get(pk=base_find.context_record.pk)
@@ -2289,9 +2350,10 @@ class GeomaticTest(FindInit, TestCase):
         tp.transform(4326)
         self.assertTrue(bfp.distance(tp) < 0.0001)
         self.assertEqual(base_find.multi_polygon, cr.multi_polygon)
-        self.assertEqual(base_find.point_source, 'P')  # precise
-        self.assertEqual(base_find.point_source_item,
-                         str(ContextRecord._meta.verbose_name))
+        self.assertEqual(base_find.point_source, "P")  # precise
+        self.assertEqual(
+            base_find.point_source_item, str(ContextRecord._meta.verbose_name)
+        )
 
         # overload of coordinates by form
         base_find = models.BaseFind.objects.get(pk=base_find.pk)
@@ -2304,19 +2366,21 @@ class GeomaticTest(FindInit, TestCase):
         base_find = models.BaseFind.objects.get(pk=base_find.pk)
         self.assertIsNotNone(base_find.point_2d)
         self.assertIsNotNone(base_find.point)
-        self.assertEqual(base_find.point_2d.wkt, 'POINT (5 6)')
-        self.assertEqual(base_find.point_source, 'P')  # precise
-        self.assertEqual(base_find.point_source_item,
-                         str(models.BaseFind._meta.verbose_name))
+        self.assertEqual(base_find.point_2d.wkt, "POINT (5 6)")
+        self.assertEqual(base_find.point_source, "P")  # precise
+        self.assertEqual(
+            base_find.point_source_item, str(models.BaseFind._meta.verbose_name)
+        )
         # re-save do not change sources
         base_find.save()
         base_find = models.BaseFind.objects.get(pk=base_find.pk)
         self.assertIsNotNone(base_find.point_2d)
         self.assertIsNotNone(base_find.point)
-        self.assertEqual(base_find.point_2d.wkt, 'POINT (5 6)')
-        self.assertEqual(base_find.point_source, 'P')  # precise
-        self.assertEqual(base_find.point_source_item,
-                         str(models.BaseFind._meta.verbose_name))
+        self.assertEqual(base_find.point_2d.wkt, "POINT (5 6)")
+        self.assertEqual(base_find.point_source, "P")  # precise
+        self.assertEqual(
+            base_find.point_source_item, str(models.BaseFind._meta.verbose_name)
+        )
 
     def test_post_save_polygon(self):
         profile = get_current_profile()
@@ -2326,16 +2390,18 @@ class GeomaticTest(FindInit, TestCase):
         find = self.finds[0]
         base_find = find.base_finds.all()[0]
         srs, __ = SpatialReferenceSystem.objects.get_or_create(
-            txt_idx='wgs84', defaults={"srid": 4326, "label": 'WGS84',
-                                       'auth_name': 'EPSG'}
+            txt_idx="wgs84",
+            defaults={"srid": 4326, "label": "WGS84", "auth_name": "EPSG"},
         )
 
         base_find = models.BaseFind.objects.get(pk=base_find.pk)
 
         # get centroid geom from poly
-        limit = 'MULTIPOLYGON(((1 1,5 1,5 5,1 5,1 1),(2 2,2 3,3 3,3 2,2 2)),' \
-                '((6 3,9 2,9 4,6 3)))'
-        base_find.multi_polygon = 'SRID=4326;' + limit
+        limit = (
+            "MULTIPOLYGON(((1 1,5 1,5 5,1 5,1 1),(2 2,2 3,3 3,3 2,2 2)),"
+            "((6 3,9 2,9 4,6 3)))"
+        )
+        base_find.multi_polygon = "SRID=4326;" + limit
         base_find.point_source = None
         base_find.point_2d = None
         base_find.point = None
@@ -2343,19 +2409,21 @@ class GeomaticTest(FindInit, TestCase):
 
         base_find = models.BaseFind.objects.get(pk=base_find.pk)
         self.assertIsNotNone(base_find.point_2d)
-        self.assertEqual(base_find.point_source, 'M')  # from multi polygon
+        self.assertEqual(base_find.point_source, "M")  # from multi polygon
         # resaving do not change source
         base_find.save()
         base_find = models.BaseFind.objects.get(pk=base_find.pk)
         self.assertIsNotNone(base_find.point_2d)
-        self.assertEqual(base_find.point_source, 'M')  # from multi polygon
+        self.assertEqual(base_find.point_source, "M")  # from multi polygon
 
         # geom from context record
-        limit = 'MULTIPOLYGON(((1 1,5 1,5 5,1 5,1 1),(2 2,2 3,3 3,3 2,2 2)),' \
-                '((6 3,9 2,9 4,6 3)))'
+        limit = (
+            "MULTIPOLYGON(((1 1,5 1,5 5,1 5,1 1),(2 2,2 3,3 3,3 2,2 2)),"
+            "((6 3,9 2,9 4,6 3)))"
+        )
         cr = ContextRecord.objects.get(pk=base_find.context_record.pk)
-        cr.multi_polygon = 'SRID=4326;' + limit
-        cr.multi_polygon_source = 'P'
+        cr.multi_polygon = "SRID=4326;" + limit
+        cr.multi_polygon_source = "P"
         cr.multi_polygon_source_item = str(ContextRecord._meta.verbose_name)
         cr.save()
         cr = ContextRecord.objects.get(pk=base_find.context_record.pk)
@@ -2364,9 +2432,10 @@ class GeomaticTest(FindInit, TestCase):
         base_find.save()
         base_find = models.BaseFind.objects.get(pk=base_find.pk)
         self.assertEqual(base_find.multi_polygon, cr.multi_polygon)
-        self.assertEqual(base_find.multi_polygon_source, 'P')  # precise
-        self.assertEqual(base_find.multi_polygon_source_item,
-                         str(ContextRecord._meta.verbose_name))
+        self.assertEqual(base_find.multi_polygon_source, "P")  # precise
+        self.assertEqual(
+            base_find.multi_polygon_source_item, str(ContextRecord._meta.verbose_name)
+        )
 
         base_find = models.BaseFind.objects.get(pk=base_find.pk)
         base_find.point_source = None
@@ -2376,42 +2445,50 @@ class GeomaticTest(FindInit, TestCase):
         base_find.save()
         base_find = models.BaseFind.objects.get(pk=base_find.pk)
         self.assertEqual(base_find.point_2d.ewkt, "SRID=4326;POINT (42 3)")
-        self.assertEqual(base_find.point_source, 'P')
+        self.assertEqual(base_find.point_source, "P")
         # resaving do not change source
         base_find.save()
         base_find = models.BaseFind.objects.get(pk=base_find.pk)
         self.assertEqual(base_find.point_2d.ewkt, "SRID=4326;POINT (42 3)")
-        self.assertEqual(base_find.point_source, 'P')
+        self.assertEqual(base_find.point_source, "P")
 
 
 class AutocompleteTest(AutocompleteTestBase, TestCase):
     fixtures = FIND_FIXTURES
     models = [
-        AcItem(models.ObjectType, 'autocomplete-objecttype'),
-        AcItem(models.MaterialType, 'autocomplete-materialtype'),
-        AcItem(models.TreatmentType, 'autocomplete-treatmenttype',
-               default_values={"virtual": False}),
-        AcItem(models.IntegrityType, 'autocomplete-integritytype'),
-        AcItem(models.TreatmentFile, 'autocomplete-treatmentfile',
-               prepare_func="create_treatmentfile"),
-        AcItem(models.FindBasket, 'autocomplete-findbasket',
-               prepare_func="create_findbasket"),
-        AcItem(models.Find, 'autocomplete-find', prepare_func="create_find"),
-        AcItem(models.Treatment, 'autocomplete-treatment',
-               prepare_func='create_treatment'),
+        AcItem(models.ObjectType, "autocomplete-objecttype"),
+        AcItem(models.MaterialType, "autocomplete-materialtype"),
+        AcItem(
+            models.TreatmentType,
+            "autocomplete-treatmenttype",
+            default_values={"virtual": False},
+        ),
+        AcItem(models.IntegrityType, "autocomplete-integritytype"),
+        AcItem(
+            models.TreatmentFile,
+            "autocomplete-treatmentfile",
+            prepare_func="create_treatmentfile",
+        ),
+        AcItem(
+            models.FindBasket,
+            "autocomplete-findbasket",
+            prepare_func="create_findbasket",
+        ),
+        AcItem(models.Find, "autocomplete-find", prepare_func="create_find"),
+        AcItem(
+            models.Treatment, "autocomplete-treatment", prepare_func="create_treatment"
+        ),
     ]
 
     def create_treatmentfile(self, base_name):
         item, __ = models.TreatmentFile.objects.get_or_create(
-            name=base_name,
-            type=models.TreatmentFileType.objects.all()[0]
+            name=base_name, type=models.TreatmentFileType.objects.all()[0]
         )
         return item, None
 
     def create_treatment(self, base_name):
         item, __ = models.Treatment.objects.get_or_create(
-            label=base_name,
-            treatment_state=models.TreatmentState.objects.all()[0]
+            label=base_name, treatment_state=models.TreatmentState.objects.all()[0]
         )
         return item, None
 
@@ -2425,13 +2502,9 @@ class AutocompleteTest(AutocompleteTestBase, TestCase):
 
     def create_find(self, base_name):
         ope, __ = Operation.objects.get_or_create(
-            common_name="Test",
-            operation_type=OperationType.objects.all()[0]
-        )
-        cr, __ = ContextRecord.objects.get_or_create(
-            operation=ope,
-            label=base_name
+            common_name="Test", operation_type=OperationType.objects.all()[0]
         )
+        cr, __ = ContextRecord.objects.get_or_create(operation=ope, label=base_name)
         base_find = models.BaseFind.objects.create(context_record=cr)
         find = models.Find.objects.create(
             label=base_name,
@@ -2447,38 +2520,44 @@ class PublicAPITest(FindInit, APITestCase):
     def setUp(self):
         self.create_finds(data_base={"label": "Find 1"}, force=True)
         self.basket = models.FindBasket.objects.create(
-            slug="my-basket", label="My basket",
-            user=IshtarUser.objects.get(pk=self.get_default_user().pk))
+            slug="my-basket",
+            label="My basket",
+            user=IshtarUser.objects.get(pk=self.get_default_user().pk),
+        )
         for find in self.finds:
             self.basket.items.add(find)
-        self.username = 'myuser'
-        self.password = 'mypassword'
-        user = User.objects.create_user(self.username, 'myemail@test.com',
-                                        self.password)
-        self.auth_token = 'Token '+ Token.objects.create(user=user).key
+        self.username = "myuser"
+        self.password = "mypassword"
+        user = User.objects.create_user(
+            self.username, "myemail@test.com", self.password
+        )
+        self.auth_token = "Token " + Token.objects.create(user=user).key
 
     def test_authentication(self):
-        url = reverse('api-public-find') + "?basket=my-basket"
-        response = self.client.get(url, format='json')
+        url = reverse("api-public-find") + "?basket=my-basket"
+        response = self.client.get(url, format="json")
         self.assertEqual(response.status_code, 401)
-        response = self.client.get(url, format='json',
-                                   HTTP_AUTHORIZATION=self.auth_token)
+        response = self.client.get(
+            url, format="json", HTTP_AUTHORIZATION=self.auth_token
+        )
         self.assertEqual(response.status_code, 200)
 
     def test_basket(self):
         # unknown basket
-        url = reverse('api-public-find') + "?basket=non-exist-basket"
-        response = self.client.get(url, format='json',
-                                   HTTP_AUTHORIZATION=self.auth_token)
+        url = reverse("api-public-find") + "?basket=non-exist-basket"
+        response = self.client.get(
+            url, format="json", HTTP_AUTHORIZATION=self.auth_token
+        )
         self.assertEqual(response.status_code, 200)
         content = response.content.decode()
         res = json.loads(content)
         self.assertEqual(res, [])
 
         # basket is not public
-        url = reverse('api-public-find') + "?basket=my-basket"
-        response = self.client.get(url, format='json',
-                                   HTTP_AUTHORIZATION=self.auth_token)
+        url = reverse("api-public-find") + "?basket=my-basket"
+        response = self.client.get(
+            url, format="json", HTTP_AUTHORIZATION=self.auth_token
+        )
         self.assertEqual(response.status_code, 200)
         content = response.content.decode()
         res = json.loads(content)
@@ -2487,8 +2566,9 @@ class PublicAPITest(FindInit, APITestCase):
         # ok
         self.basket.public = True
         self.basket.save()
-        response = self.client.get(url, format='json',
-                                   HTTP_AUTHORIZATION=self.auth_token)
+        response = self.client.get(
+            url, format="json", HTTP_AUTHORIZATION=self.auth_token
+        )
         self.assertEqual(response.status_code, 200)
         content = response.content.decode()
         res = json.loads(content)
@@ -2497,26 +2577,31 @@ class PublicAPITest(FindInit, APITestCase):
     def test_basket_content(self):
         find = self.finds[0]
         find.denomination = "denomination"
-        ceram = models.MaterialType.objects.get(txt_idx='ceramic')
+        ceram = models.MaterialType.objects.get(txt_idx="ceramic")
         find.material_types.add(ceram)
         find.save()
 
-        url = reverse('api-public-find') + "?basket=my-basket"
+        url = reverse("api-public-find") + "?basket=my-basket"
         self.basket.public = True
         self.basket.save()
-        response = self.client.get(url, format='json',
-                                   HTTP_AUTHORIZATION=self.auth_token)
+        response = self.client.get(
+            url, format="json", HTTP_AUTHORIZATION=self.auth_token
+        )
         self.assertEqual(response.status_code, 200)
         content = response.content.decode()
         res = json.loads(content)
         expected_results = [
-            ((0, 'denomination',), 'denomination'),
-            ((0, 'materials', 0), 'Céramique'),
-            ((0, 'base-finds', 0, 'context-record', 'label'),
-             'Context record'),
-            ((0, 'base-finds', 0, 'context-record', 'town'),
-             'default_town (12345)'),
-            ((0, 'base-finds', 0, 'context-record', 'operation', 'year'), 2010),
+            (
+                (
+                    0,
+                    "denomination",
+                ),
+                "denomination",
+            ),
+            ((0, "materials", 0), "Céramique"),
+            ((0, "base-finds", 0, "context-record", "label"), "Context record"),
+            ((0, "base-finds", 0, "context-record", "town"), "default_town (12345)"),
+            ((0, "base-finds", 0, "context-record", "operation", "year"), 2010),
         ]
         for path, result in expected_results:
             path = list(reversed(path))
@@ -2537,19 +2622,24 @@ class LabelTest(FindInit, TestCase):
 
     def setUp(self):
         templates = [
-            settings.ROOT_PATH + '../archaeological_finds/tests/' + t
-            for t in ("etiquettes-mobilier.odt", "etiquettes-mobilier",
-                      "etiquettes-mobilier.txt", "bad_lo.zip",
-                      "truncated_xml.zip")
+            settings.ROOT_PATH + "../archaeological_finds/tests/" + t
+            for t in (
+                "etiquettes-mobilier.odt",
+                "etiquettes-mobilier",
+                "etiquettes-mobilier.txt",
+                "bad_lo.zip",
+                "truncated_xml.zip",
+            )
         ]
         self.templates = []
         for template in templates:
             filename = template.split("/")[-1]
-            shutil.copy(template,
-                        os.path.join(settings.MEDIA_ROOT, filename),
-                        follow_symlinks=True)
-            self.templates.append(
-                os.path.join(settings.MEDIA_ROOT, filename))
+            shutil.copy(
+                template,
+                os.path.join(settings.MEDIA_ROOT, filename),
+                follow_symlinks=True,
+            )
+            self.templates.append(os.path.join(settings.MEDIA_ROOT, filename))
 
     def tearDown(self):
         for tpl in self.templates:
@@ -2563,19 +2653,22 @@ class LabelTest(FindInit, TestCase):
             (base_tpl, base_targets, True, "OK"),
             (base_tpl, "", False, "no target"),
             (base_tpl, "-;Cadre2;Cadre3", False, "bad first target"),
-            (base_tpl, "Cadre1;Frame2;Frame3", True,
-             "first target OK, silently failed other targets"),
+            (
+                base_tpl,
+                "Cadre1;Frame2;Frame3",
+                True,
+                "first target OK, silently failed other targets",
+            ),
             (missing_ext, base_targets, True, "missing extension"),
             (text_file, base_targets, False, "text file"),
             (bad_lo, base_targets, False, "missing content.xml"),
             (trunc_xml, base_targets, False, "truncated content.xml"),
         )
         for tpl_file, targets, is_ok, msg in dataset:
-            with open(tpl_file, 'rb') as tpl:
-                template = SimpleUploadedFile("etiquettes-mobilier.odt",
-                                              tpl.read())
+            with open(tpl_file, "rb") as tpl:
+                template = SimpleUploadedFile("etiquettes-mobilier.odt", tpl.read())
                 model, __ = ImporterModel.objects.get_or_create(
-                    klass='archaeological_finds.models.Find'
+                    klass="archaeological_finds.models.Find"
                 )
                 q = DocumentTemplate.objects.filter(slug="test")
                 if q.count():
@@ -2586,7 +2679,8 @@ class LabelTest(FindInit, TestCase):
                     associated_model=model,
                     available=True,
                     label_targets=targets,
-                    label_template=template)
+                    label_template=template,
+                )
             self.templates.append(doc.label_template.path)
             doc = DocumentTemplate.objects.get(pk=doc.pk)
             msg = "Fail on dataset: " + msg
@@ -2602,22 +2696,19 @@ class TemplateTest(FindInit, TestCase):
     model = models.Find
 
     def setUp(self):
-        template = settings.ROOT_PATH + \
-                   '../archaeological_finds/tests/notices-panier.odt'
+        template = (
+            settings.ROOT_PATH + "../archaeological_finds/tests/notices-panier.odt"
+        )
         filename = template.split("/")[-1]
-        shutil.copy(template,
-                    os.path.join(settings.MEDIA_ROOT, filename),
-                    follow_symlinks=True)
+        shutil.copy(
+            template, os.path.join(settings.MEDIA_ROOT, filename), follow_symlinks=True
+        )
         self.template = os.path.join(settings.MEDIA_ROOT, filename)
         self.templates = [self.template]
         ope1 = self.create_operation()[0]
         ope2 = self.create_operation()[1]
-        cr = self.create_context_record(
-            data={"label": "CR 1", "operation": ope1}
-        )[0]
-        cr2 = self.create_context_record(
-            data={"label": "CR 2", "operation": ope2}
-        )[1]
+        cr = self.create_context_record(data={"label": "CR 1", "operation": ope1})[0]
+        cr2 = self.create_context_record(data={"label": "CR 2", "operation": ope2})[1]
         self.create_finds(data_base={"context_record": cr})[0]
         self.create_finds(data_base={"context_record": cr2})[1]
         self.basket = models.FindBasket.objects.create(label="Hophop")
@@ -2627,17 +2718,14 @@ class TemplateTest(FindInit, TestCase):
         location = Warehouse.objects.create(name="Warehouse", warehouse_type=wt)
         ct, __ = ContainerType.objects.get_or_create(label="CT", txt_idx="CT")
         self.container = Container.objects.create(
-            location=location,
-            reference="Reférence",
-            container_type=ct
+            location=location, reference="Reférence", container_type=ct
         )
 
     def test_label(self):
-        with open(self.template, 'rb') as tpl:
-            template = SimpleUploadedFile("template.odt",
-                                          tpl.read())
+        with open(self.template, "rb") as tpl:
+            template = SimpleUploadedFile("template.odt", tpl.read())
             model, __ = ImporterModel.objects.get_or_create(
-                klass='archaeological_finds.models.Find'
+                klass="archaeological_finds.models.Find"
             )
             q = DocumentTemplate.objects.filter(slug="test")
             if q.count():
@@ -2647,7 +2735,8 @@ class TemplateTest(FindInit, TestCase):
                 slug="test",
                 associated_model=model,
                 available=True,
-                template=template)
+                template=template,
+            )
         self.templates.append(doc.template.path)
         doc = DocumentTemplate.objects.get(pk=doc.pk)