Format - black: context_records

10 files changed, 1721 insertions, 1280 deletions

diff --git a/archaeological_context_records/admin.py b/archaeological_context_records/admin.py
index abee0a6d0..f9c8e03ff 100644
--- a/archaeological_context_records/admin.py
+++ b/archaeological_context_records/admin.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 # Copyright (C) 2012-2015 Étienne Loks  <etienne.loks_AT_peacefrogsDOTnet>
 
@@ -32,12 +32,15 @@ from . import models
 
 
 class DatingAdmin(admin.ModelAdmin):
-    list_display = ('period', 'context_records_lbl', 'finds_lbl')
-    list_filter = ("period", 'dating_type', 'quality')
+    list_display = ("period", "context_records_lbl", "finds_lbl")
+    list_filter = ("period", "dating_type", "quality")
     model = models.Dating
-    search_fields = ['context_records__cached_label', 'period__label',
-                     'find__cached_label']
-    readonly_fields = ['context_records_lbl', 'finds_lbl']
+    search_fields = [
+        "context_records__cached_label",
+        "period__label",
+        "find__cached_label",
+    ]
+    readonly_fields = ["context_records_lbl", "finds_lbl"]
 
 
 admin_site.register(models.Dating, DatingAdmin)
@@ -47,27 +50,32 @@ class AdminContextRecordForm(forms.ModelForm):
     class Meta:
         model = models.ContextRecord
         exclude = []
-    point_2d = PointField(label=_("Point"), required=False,
-                          widget=OSMWidget)
-    multi_polygon = MultiPolygonField(label=_("Multi polygon"), required=False,
-                                      widget=OSMWidget)
-    operation = AutoCompleteSelectField('operation')
-    parcel = AutoCompleteSelectField('parcel', required=False)
-    town = AutoCompleteSelectField('town', required=False)
-    archaeological_site = AutoCompleteSelectField('archaeological_site',
-                                                  required=False)
-    lock_user = AutoCompleteSelectField('user', required=False)
+
+    point_2d = PointField(label=_("Point"), required=False, widget=OSMWidget)
+    multi_polygon = MultiPolygonField(
+        label=_("Multi polygon"), required=False, widget=OSMWidget
+    )
+    operation = AutoCompleteSelectField("operation")
+    parcel = AutoCompleteSelectField("parcel", required=False)
+    town = AutoCompleteSelectField("town", required=False)
+    archaeological_site = AutoCompleteSelectField("archaeological_site", required=False)
+    lock_user = AutoCompleteSelectField("user", required=False)
 
 
 class ContextRecordAdmin(HistorizedObjectAdmin):
-    list_display = ('label', 'operation', 'parcel')
-    list_filter = ('unit',)
-    search_fields = ('label', 'parcel__operation__cached_label',
-                     'parcel__section', 'parcel__parcel_number')
+    list_display = ("label", "operation", "parcel")
+    list_filter = ("unit",)
+    search_fields = (
+        "label",
+        "parcel__operation__cached_label",
+        "parcel__section",
+        "parcel__parcel_number",
+    )
     model = models.ContextRecord
     form = AdminContextRecordForm
     readonly_fields = HistorizedObjectAdmin.readonly_fields + [
-        'cached_label', 'datings'
+        "cached_label",
+        "datings",
     ]
     exclude = ["documents", "main_image"]
 
@@ -76,44 +84,58 @@ admin_site.register(models.ContextRecord, ContextRecordAdmin)
 
 
 class RecordRelationsAdmin(admin.ModelAdmin):
-    list_display = ('left_record', 'relation_type', 'right_record')
-    list_filter = ('relation_type',)
+    list_display = ("left_record", "relation_type", "right_record")
+    list_filter = ("relation_type",)
     model = models.RecordRelations
-    form = make_ajax_form(model, {
-        'left_record': 'context_record',
-        'right_record': 'context_record',
-    })
+    form = make_ajax_form(
+        model,
+        {
+            "left_record": "context_record",
+            "right_record": "context_record",
+        },
+    )
 
 
 admin_site.register(models.RecordRelations, RecordRelationsAdmin)
 
 
 class RelationTypeAdmin(GeneralTypeAdmin):
-    list_display = ('label', 'txt_idx', 'tiny_label', 'available',
-                    'symmetrical', 'logical_relation', 'inverse_relation',
-                    'order', 'comment')
+    list_display = (
+        "label",
+        "txt_idx",
+        "tiny_label",
+        "available",
+        "symmetrical",
+        "logical_relation",
+        "inverse_relation",
+        "order",
+        "comment",
+    )
 
 
 admin_site.register(models.RelationType, RelationTypeAdmin)
 
 
 class UnitAdmin(GeneralTypeAdmin):
-    list_display = ['label', 'txt_idx', 'parent', 'available', 'order',
-                    'comment']
+    list_display = ["label", "txt_idx", "parent", "available", "order", "comment"]
+
 
 admin_site.register(models.Unit, UnitAdmin)
 
- 
+
 class IdentificationTypeAdmin(GeneralTypeAdmin):
-    list_display = ['label', 'txt_idx', 'available', 'order', 'comment']
+    list_display = ["label", "txt_idx", "available", "order", "comment"]
+
 
 admin_site.register(models.IdentificationType, IdentificationTypeAdmin)
 
 
 general_models = [
-    models.DatingType, models.DatingQuality, models.DocumentationType,
-    models.ActivityType, models.ExcavationTechnicType]
+    models.DatingType,
+    models.DatingQuality,
+    models.DocumentationType,
+    models.ActivityType,
+    models.ExcavationTechnicType,
+]
 for model in general_models:
     admin_site.register(model, GeneralTypeAdmin)
-
-
diff --git a/archaeological_context_records/forms.py b/archaeological_context_records/forms.py
index c4fa6f8fe..d727dae27 100644
--- a/archaeological_context_records/forms.py
+++ b/archaeological_context_records/forms.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 # Copyright (C) 2010-2016  Étienne Loks  <etienne.loks_AT_peacefrogsDOTnet>
 
@@ -29,19 +29,45 @@ from django.core import validators
 from django.forms.formsets import formset_factory
 from ishtar_common.utils import ugettext_lazy as _
 
-from ishtar_common.models import valid_id, IshtarSiteProfile, Town, \
-    SpatialReferenceSystem, valid_ids
+from ishtar_common.models import (
+    valid_id,
+    IshtarSiteProfile,
+    Town,
+    SpatialReferenceSystem,
+    valid_ids,
+)
 from archaeological_context_records import models
 
-from ishtar_common.forms import FinalForm, FormSet, \
-    reverse_lazy, get_form_selection, ManageOldType, CustomForm, \
-    FieldType, CustomFormSearch, IshtarForm, FormHeader, HistorySelect, \
-    MultiSearchForm, LockForm, DocumentItemSelect
+from ishtar_common.forms import (
+    FinalForm,
+    FormSet,
+    reverse_lazy,
+    get_form_selection,
+    ManageOldType,
+    CustomForm,
+    FieldType,
+    CustomFormSearch,
+    IshtarForm,
+    FormHeader,
+    HistorySelect,
+    MultiSearchForm,
+    LockForm,
+    DocumentItemSelect,
+)
 from ishtar_common.forms_common import get_town_field
-from archaeological_operations.forms import OperationSelect, ParcelField, \
-    RecordRelationsForm as OpeRecordRelationsForm, RecordRelationsFormSetBase
-from archaeological_operations.models import Period, Parcel, Operation, \
-    ArchaeologicalSite, RelationType as OpeRelationType
+from archaeological_operations.forms import (
+    OperationSelect,
+    ParcelField,
+    RecordRelationsForm as OpeRecordRelationsForm,
+    RecordRelationsFormSetBase,
+)
+from archaeological_operations.models import (
+    Period,
+    Parcel,
+    Operation,
+    ArchaeologicalSite,
+    RelationType as OpeRelationType,
+)
 from archaeological_operations.widgets import OAWidget
 from bootstrap_datepicker.widgets import DatePicker
 from ishtar_common import widgets
@@ -51,46 +77,48 @@ class OperationFormSelection(CustomForm, forms.Form):
     form_label = _("Operation")
     form_admin_name = _("Context record - 010 - Operation choice")
     form_slug = "contextrecord-010-operationchoice"
-    associated_models = {'operation': Operation}
-    currents = {'operation': Operation}
+    associated_models = {"operation": Operation}
+    currents = {"operation": Operation}
     operation = forms.IntegerField(
-        label=_("Operation"), required=False,
+        label=_("Operation"),
+        required=False,
         widget=widgets.JQueryAutoComplete(
-            reverse_lazy('autocomplete-operation'),
-            associated_model=Operation),
-        validators=[valid_id(Operation)])
+            reverse_lazy("autocomplete-operation"), associated_model=Operation
+        ),
+        validators=[valid_id(Operation)],
+    )
 
 
 class PeriodSelect(forms.Form):
-    datings__period = forms.ChoiceField(label=_("Dating - period"),
-                                        choices=[])
-    datings__precise_dating = forms.CharField(
-        label=_("Dating - precise"))
+    datings__period = forms.ChoiceField(label=_("Dating - period"), choices=[])
+    datings__precise_dating = forms.CharField(label=_("Dating - precise"))
     datings__start_date__before = forms.IntegerField(
-        label=_("Dating - start date before"))
+        label=_("Dating - start date before")
+    )
     datings__start_date__after = forms.IntegerField(
-        label=_("Dating - start date after"))
-    datings__end_date__before = forms.IntegerField(
-        label=_("Dating - end date before"))
-    datings__end_date__after = forms.IntegerField(
-        label=_("Dating - end date after"))
-    datings__dating_type = forms.ChoiceField(label=_("Dating - dating type"),
-                                             choices=[])
-    datings__quality = forms.ChoiceField(label=_("Dating - dating quality"),
-                                         choices=[])
+        label=_("Dating - start date after")
+    )
+    datings__end_date__before = forms.IntegerField(label=_("Dating - end date before"))
+    datings__end_date__after = forms.IntegerField(label=_("Dating - end date after"))
+    datings__dating_type = forms.ChoiceField(
+        label=_("Dating - dating type"), choices=[]
+    )
+    datings__quality = forms.ChoiceField(label=_("Dating - dating quality"), choices=[])
     TYPES = [
-        FieldType('datings__period', Period),
-        FieldType('datings__dating_type', models.DatingType),
-        FieldType('datings__quality', models.DatingQuality),
+        FieldType("datings__period", Period),
+        FieldType("datings__dating_type", models.DatingType),
+        FieldType("datings__quality", models.DatingQuality),
+    ]
+    PERIOD_FIELDS = [
+        "datings__period",
+        "datings__precise_dating",
+        "datings__start_date__before",
+        "datings__start_date__after",
+        "datings__end_date__before",
+        "datings__end_date__after",
+        "datings__dating_type",
+        "datings__quality",
     ]
-    PERIOD_FIELDS = ["datings__period",
-                     "datings__precise_dating",
-                     "datings__start_date__before",
-                     "datings__start_date__after",
-                     "datings__end_date__before",
-                     "datings__end_date__after",
-                     "datings__dating_type",
-                     "datings__quality"]
 
     def _reorder_period_fields(self, insert_period_after):
         fields = OrderedDict()
@@ -110,37 +138,41 @@ class RecordSelect(DocumentItemSelect, PeriodSelect):
     form_slug = "contextrecord-001-search"
 
     search_vector = forms.CharField(
-        label=_("Full text search"), widget=widgets.SearchWidget(
-            'archaeological-context-records', 'contextrecord'
-        ))
+        label=_("Full text search"),
+        widget=widgets.SearchWidget("archaeological-context-records", "contextrecord"),
+    )
     label = forms.CharField(label=_("ID"), max_length=100)
     town = get_town_field()
-    if settings.COUNTRY == 'fr':
+    if settings.COUNTRY == "fr":
         operation__code_patriarche = forms.CharField(
-            max_length=500,
-            widget=OAWidget,
-            label=_("Code PATRIARCHE"))
+            max_length=500, widget=OAWidget, label=_("Code PATRIARCHE")
+        )
     operation__year = forms.IntegerField(label=_("Operation's year"))
     operation__operation_code = forms.IntegerField(
-        label=_("Operation's number (index by year)"))
+        label=_("Operation's number (index by year)")
+    )
     archaeological_site = forms.IntegerField(
         label=_("Archaeological site"),
         widget=widgets.JQueryAutoComplete(
-            reverse_lazy('autocomplete-archaeologicalsite'),
-            associated_model=ArchaeologicalSite),
-        validators=[valid_id(ArchaeologicalSite)])
+            reverse_lazy("autocomplete-archaeologicalsite"),
+            associated_model=ArchaeologicalSite,
+        ),
+        validators=[valid_id(ArchaeologicalSite)],
+    )
     ope_relation_types = forms.ChoiceField(
-        label=_("Search within related operations"), choices=[])
+        label=_("Search within related operations"), choices=[]
+    )
     unit = forms.ChoiceField(label=_("Unit type"), choices=[])
     parcel = forms.CharField(label=_("Parcel"))
     has_finds = forms.NullBooleanField(label=_("Has finds"))
     cr_relation_types = forms.ChoiceField(
-        label=_("Search within relations"), choices=[])
+        label=_("Search within relations"), choices=[]
+    )
 
     TYPES = PeriodSelect.TYPES + [
-        FieldType('unit', models.Unit),
-        FieldType('cr_relation_types', models.RelationType),
-        FieldType('ope_relation_types', OpeRelationType),
+        FieldType("unit", models.Unit),
+        FieldType("cr_relation_types", models.RelationType),
+        FieldType("ope_relation_types", OpeRelationType),
     ]
     SITE_KEYS = {"archaeological_site": None}
 
@@ -150,48 +182,58 @@ class RecordSelect(DocumentItemSelect, PeriodSelect):
 
     def get_input_ids(self):
         ids = super(RecordSelect, self).get_input_ids()
-        if 'cr_relation_types' in ids:
-            ids.pop(ids.index('cr_relation_types'))
-            for idx, c in enumerate(self.fields['cr_relation_types'].choices):
-                ids.append('cr_relation_types_{}'.format(idx))
-        if 'ope_relation_types' in ids:
-            ids.pop(ids.index('ope_relation_types'))
-            for idx, c in enumerate(self.fields['ope_relation_types'].choices):
-                ids.append('ope_relation_types_{}'.format(idx))
+        if "cr_relation_types" in ids:
+            ids.pop(ids.index("cr_relation_types"))
+            for idx, c in enumerate(self.fields["cr_relation_types"].choices):
+                ids.append("cr_relation_types_{}".format(idx))
+        if "ope_relation_types" in ids:
+            ids.pop(ids.index("ope_relation_types"))
+            for idx, c in enumerate(self.fields["ope_relation_types"].choices):
+                ids.append("ope_relation_types_{}".format(idx))
         return ids
 
 
 class RecordFormSelection(LockForm, CustomFormSearch):
     SEARCH_AND_SELECT = True
     form_label = _("Context record search")
-    pk_key = 'pk'
-    associated_models = {'pk': models.ContextRecord}
-    currents = {'pk': models.ContextRecord}
+    pk_key = "pk"
+    associated_models = {"pk": models.ContextRecord}
+    currents = {"pk": models.ContextRecord}
 
     pk = forms.IntegerField(
-        label="", required=False,
+        label="",
+        required=False,
         widget=widgets.DataTable(
-            reverse_lazy('get-contextrecord'),
-            RecordSelect, models.ContextRecord,
-            gallery=True, map=True,
-            source_full=reverse_lazy('get-contextrecord-full')),
-        validators=[valid_id(models.ContextRecord)])
+            reverse_lazy("get-contextrecord"),
+            RecordSelect,
+            models.ContextRecord,
+            gallery=True,
+            map=True,
+            source_full=reverse_lazy("get-contextrecord-full"),
+        ),
+        validators=[valid_id(models.ContextRecord)],
+    )
 
 
 class RecordFormMultiSelection(LockForm, MultiSearchForm):
     form_label = _("Context record search")
-    associated_models = {'pks': models.ContextRecord}
-    pk_key = 'pks'
+    associated_models = {"pks": models.ContextRecord}
+    pk_key = "pks"
 
     pk = forms.CharField(
-        label="", required=False,
+        label="",
+        required=False,
         widget=widgets.DataTable(
-            reverse_lazy('get-contextrecord'),
-            RecordSelect, models.ContextRecord,
+            reverse_lazy("get-contextrecord"),
+            RecordSelect,
+            models.ContextRecord,
             multiple_select=True,
-            gallery=True, map=True,
-            source_full=reverse_lazy('get-contextrecord-full')),
-        validators=[valid_ids(models.ContextRecord)])
+            gallery=True,
+            map=True,
+            source_full=reverse_lazy("get-contextrecord-full"),
+        ),
+        validators=[valid_ids(models.ContextRecord)],
+    )
 
 
 def get_init_parcel(form, operation, prefix=""):
@@ -199,23 +241,26 @@ def get_init_parcel(form, operation, prefix=""):
     sort = lambda x: (x.town.name, x.section)
     parcels = sorted(parcels, key=sort)
     for key, gparcels in groupby(parcels, sort):
-        form.fields[prefix + 'parcel'].choices.append(
+        form.fields[prefix + "parcel"].choices.append(
             (
                 " - ".join(k for k in key if k),
                 [(parcel.pk, parcel.short_label) for parcel in gparcels],
             )
         )
 
-    if len(form.fields[prefix + 'parcel'].choices) == 1 and \
-            (prefix + 'town') in form.fields:
+    if (
+        len(form.fields[prefix + "parcel"].choices) == 1
+        and (prefix + "town") in form.fields
+    ):
         # only the empty choice is available
-        form.fields.pop(prefix + 'parcel')
-        form.fields[prefix + 'town'].required = True
-    if (prefix + 'town') in form.fields:
-        if form.fields[prefix + 'town'].required:
-            form.fields[prefix + 'town'].choices = []  # remove the empty choice
-        form.fields[prefix + 'town'].choices += [
-            (t.pk, str(t)) for t in operation.towns.all()]
+        form.fields.pop(prefix + "parcel")
+        form.fields[prefix + "town"].required = True
+    if (prefix + "town") in form.fields:
+        if form.fields[prefix + "town"].required:
+            form.fields[prefix + "town"].choices = []  # remove the empty choice
+        form.fields[prefix + "town"].choices += [
+            (t.pk, str(t)) for t in operation.towns.all()
+        ]
 
 
 class RecordFormGeneral(CustomForm, ManageOldType):
@@ -226,96 +271,122 @@ class RecordFormGeneral(CustomForm, ManageOldType):
     file_upload = True
     base_models = ["documentation"]
     associated_models = {
-        'archaeological_site': ArchaeologicalSite,
-        'parcel': Parcel, 'unit': models.Unit, 'town': Town,
-        'documentation': models.DocumentationType,
-        'spatial_reference_system': SpatialReferenceSystem,
-        'excavation_technic': models.ExcavationTechnicType}
+        "archaeological_site": ArchaeologicalSite,
+        "parcel": Parcel,
+        "unit": models.Unit,
+        "town": Town,
+        "documentation": models.DocumentationType,
+        "spatial_reference_system": SpatialReferenceSystem,
+        "excavation_technic": models.ExcavationTechnicType,
+    }
     pk = forms.IntegerField(required=False, widget=forms.HiddenInput)
     operation_id = forms.IntegerField(widget=forms.HiddenInput)
     parcel = forms.ChoiceField(label=_("Parcel"), choices=[])
     town = forms.ChoiceField(label=_("Town"), choices=[], required=False)
     archaeological_site = forms.ChoiceField(
-        label=" ", choices=[], required=False,
-        help_text=_("Only the items associated to the operation can be "
-                    "selected.")
-    )
-    label = forms.CharField(label=_("ID"),
-                            validators=[validators.MaxLengthValidator(200)])
-    unit = forms.ChoiceField(label=_("Context record type"), required=False,
-                             choices=[])
-    description = forms.CharField(label=_("Description"),
-                                  widget=forms.Textarea, required=False)
-    comment = forms.CharField(label=_("General comment"),
-                              widget=forms.Textarea, required=False)
+        label=" ",
+        choices=[],
+        required=False,
+        help_text=_("Only the items associated to the operation can be " "selected."),
+    )
+    label = forms.CharField(
+        label=_("ID"), validators=[validators.MaxLengthValidator(200)]
+    )
+    unit = forms.ChoiceField(label=_("Context record type"), required=False, choices=[])
+    description = forms.CharField(
+        label=_("Description"), widget=forms.Textarea, required=False
+    )
+    comment = forms.CharField(
+        label=_("General comment"), widget=forms.Textarea, required=False
+    )
     excavation_technic = forms.ChoiceField(
-        label=_("Excavation technique"), choices=[], required=False)
+        label=_("Excavation technique"), choices=[], required=False
+    )
     surface = forms.IntegerField(
-        required=False, widget=widgets.AreaWidget,
+        required=False,
+        widget=widgets.AreaWidget,
         label=_("Total surface (m2)"),
-        validators=[validators.MinValueValidator(0),
-                    validators.MaxValueValidator(999999999)])
+        validators=[
+            validators.MinValueValidator(0),
+            validators.MaxValueValidator(999999999),
+        ],
+    )
     length = forms.FloatField(label=_("Length (m)"), required=False)
     width = forms.FloatField(label=_("Width (m)"), required=False)
     thickness = forms.FloatField(label=_("Thickness (m)"), required=False)
     diameter = forms.FloatField(label=_("Diameter (m)"), required=False)
     depth = forms.FloatField(label=_("Depth (m)"), required=False)
     depth_of_appearance = forms.FloatField(
-        label=_("Depth of appearance (m)"), required=False)
-    opening_date = forms.DateField(label=_("Opening date"),
-                                   widget=DatePicker, required=False)
-    closing_date = forms.DateField(label=_("Closing date"),
-                                   widget=DatePicker, required=False)
+        label=_("Depth of appearance (m)"), required=False
+    )
+    opening_date = forms.DateField(
+        label=_("Opening date"), widget=DatePicker, required=False
+    )
+    closing_date = forms.DateField(
+        label=_("Closing date"), widget=DatePicker, required=False
+    )
     documentation = forms.MultipleChoiceField(
-        label=_("Documentation"), choices=[], required=False,
-        widget=widgets.Select2Multiple)
+        label=_("Documentation"),
+        choices=[],
+        required=False,
+        widget=widgets.Select2Multiple,
+    )
     location = forms.CharField(
-        label=_("Location"), widget=forms.Textarea,
-        required=False, validators=[validators.MaxLengthValidator(200)])
+        label=_("Location"),
+        widget=forms.Textarea,
+        required=False,
+        validators=[validators.MaxLengthValidator(200)],
+    )
 
-    HEADERS['x'] = FormHeader(_("Coordinates"))
+    HEADERS["x"] = FormHeader(_("Coordinates"))
     x = forms.FloatField(label=_("X"), required=False)
-    estimated_error_x = forms.FloatField(label=_("Estimated error for X"),
-                                         required=False)
+    estimated_error_x = forms.FloatField(
+        label=_("Estimated error for X"), required=False
+    )
     y = forms.FloatField(label=_("Y"), required=False)
-    estimated_error_y = forms.FloatField(label=_("Estimated error for Y"),
-                                         required=False)
+    estimated_error_y = forms.FloatField(
+        label=_("Estimated error for Y"), required=False
+    )
     z = forms.FloatField(label=_("Z"), required=False)
-    estimated_error_z = forms.FloatField(label=_("Estimated error for Z"),
-                                         required=False)
+    estimated_error_z = forms.FloatField(
+        label=_("Estimated error for Z"), required=False
+    )
     spatial_reference_system = forms.ChoiceField(
-        label=_("Spatial Reference System"), required=False, choices=[])
+        label=_("Spatial Reference System"), required=False, choices=[]
+    )
 
     TYPES = [
-        FieldType('unit', models.Unit),
-        FieldType('excavation_technic', models.ExcavationTechnicType),
-        FieldType('documentation', models.DocumentationType, is_multiple=True),
-        FieldType('spatial_reference_system', SpatialReferenceSystem),
+        FieldType("unit", models.Unit),
+        FieldType("excavation_technic", models.ExcavationTechnicType),
+        FieldType("documentation", models.DocumentationType, is_multiple=True),
+        FieldType("spatial_reference_system", SpatialReferenceSystem),
     ]
 
     PROFILE_FILTER = {
-        'mapping': [
-            'x',
-            'y',
-            'z',
-            'estimated_error_x',
-            'estimated_error_y',
-            'estimated_error_z',
-            'spatial_reference_system'
+        "mapping": [
+            "x",
+            "y",
+            "z",
+            "estimated_error_x",
+            "estimated_error_y",
+            "estimated_error_z",
+            "spatial_reference_system",
         ],
     }
 
     def __init__(self, *args, **kwargs):
         # TODO: simplify
         operation = None
-        if 'data' in kwargs and kwargs['data'] and \
-                ('operation' in kwargs['data'] or
-                 'context_record' in kwargs['data']):
-            if 'operation' in kwargs['data']:
-                operation = kwargs['data'].pop('operation')
+        if (
+            "data" in kwargs
+            and kwargs["data"]
+            and ("operation" in kwargs["data"] or "context_record" in kwargs["data"])
+        ):
+            if "operation" in kwargs["data"]:
+                operation = kwargs["data"].pop("operation")
                 if type(operation) in (list, tuple):
                     operation = operation[0]
-                if not hasattr(operation, 'id'):
+                if not hasattr(operation, "id"):
                     operation_id = operation
                     try:
                         operation = Operation.objects.get(pk=operation_id)
@@ -323,42 +394,43 @@ class RecordFormGeneral(CustomForm, ManageOldType):
                         operation = None
                 # force operation modification
                 # if posted
-                if operation and kwargs['data']:
-                    if hasattr(operation, 'id'):
-                        kwargs['data'][kwargs['prefix'] + '-operation_id'] = \
-                            operation.id
+                if operation and kwargs["data"]:
+                    if hasattr(operation, "id"):
+                        kwargs["data"][
+                            kwargs["prefix"] + "-operation_id"
+                        ] = operation.id
                     else:
-                        kwargs['data'][kwargs['prefix'] + '-operation_id'] = \
-                            operation
-            if 'context_record' in kwargs['data'] and \
-               kwargs['data']['context_record']:
-                operation = kwargs['data']['context_record'].operation
+                        kwargs["data"][kwargs["prefix"] + "-operation_id"] = operation
+            if "context_record" in kwargs["data"] and kwargs["data"]["context_record"]:
+                operation = kwargs["data"]["context_record"].operation
             # clean data if not "real" data
             # prefix_value = kwargs['prefix']
-            if not [k for k in kwargs['data'].keys()
-                    if k.startswith(kwargs['prefix']) and kwargs['data'][k]]:
-                kwargs['data'] = None
-                if 'files' in kwargs:
-                    kwargs.pop('files')
+            if not [
+                k
+                for k in kwargs["data"].keys()
+                if k.startswith(kwargs["prefix"]) and kwargs["data"][k]
+            ]:
+                kwargs["data"] = None
+                if "files" in kwargs:
+                    kwargs.pop("files")
         super(RecordFormGeneral, self).__init__(*args, **kwargs)
         profile = IshtarSiteProfile.get_current_profile()
-        self.fields['parcel'].choices = [('', '--')]
+        self.fields["parcel"].choices = [("", "--")]
         if not profile.parcel_mandatory:
-            self.fields['parcel'].required = False
-            self.fields['town'].choices = [('', '--')]
+            self.fields["parcel"].required = False
+            self.fields["town"].choices = [("", "--")]
         else:
-            self.fields.pop('town')
+            self.fields.pop("town")
 
         site_label = IshtarSiteProfile.get_default_site_label()
-        self.fields['archaeological_site'].label = site_label
-        self.fields['archaeological_site'].choices = [('', '--')]
+        self.fields["archaeological_site"].label = site_label
+        self.fields["archaeological_site"].choices = [("", "--")]
 
         if operation:
-            self.fields['operation_id'].initial = operation.pk
+            self.fields["operation_id"].initial = operation.pk
             get_init_parcel(self, operation)
-            self.fields['archaeological_site'].choices += [
-                (site.pk, str(site))
-                for site in operation.archaeological_sites.all()
+            self.fields["archaeological_site"].choices += [
+                (site.pk, str(site)) for site in operation.archaeological_sites.all()
             ]
 
     def clean(self):
@@ -367,43 +439,44 @@ class RecordFormGeneral(CustomForm, ManageOldType):
         operation_id = cleaned_data.get("operation_id")
         label = cleaned_data.get("label")
         cr = models.ContextRecord.objects.filter(
-            label=label, parcel__operation__pk=operation_id)
-        if 'pk' in cleaned_data and cleaned_data['pk']:
-            cr = cr.exclude(pk=int(cleaned_data['pk']))
+            label=label, parcel__operation__pk=operation_id
+        )
+        if "pk" in cleaned_data and cleaned_data["pk"]:
+            cr = cr.exclude(pk=int(cleaned_data["pk"]))
         if cr.count():
-            raise forms.ValidationError(_("This ID already exists for "
-                                          "this operation."))
-        if not self.cleaned_data.get('parcel', None) and not \
-                self.cleaned_data.get('town', None):
-            raise forms.ValidationError(_("You have to choose a town or a "
-                                          "parcel."))
+            raise forms.ValidationError(
+                _("This ID already exists for " "this operation.")
+            )
+        if not self.cleaned_data.get("parcel", None) and not self.cleaned_data.get(
+            "town", None
+        ):
+            raise forms.ValidationError(_("You have to choose a town or a " "parcel."))
         return cleaned_data
 
 
 class DatingForm(ManageOldType, forms.Form):
     form_label = _("Dating")
-    base_model = 'dating'
-    associated_models = {'dating_type': models.DatingType,
-                         'quality': models.DatingQuality,
-                         'period': models.Period}
+    base_model = "dating"
+    associated_models = {
+        "dating_type": models.DatingType,
+        "quality": models.DatingQuality,
+        "period": models.Period,
+    }
     period = forms.ChoiceField(label=_("Period"), choices=[])
     start_date = forms.IntegerField(label=_("Start date"), required=False)
     end_date = forms.IntegerField(label=_("End date"), required=False)
     quality = forms.ChoiceField(label=_("Quality"), required=False, choices=[])
-    dating_type = forms.ChoiceField(label=_("Dating type"), required=False,
-                                    choices=[])
-    precise_dating = forms.CharField(label=_("Precise dating"),
-                                     required=False)
+    dating_type = forms.ChoiceField(label=_("Dating type"), required=False, choices=[])
+    precise_dating = forms.CharField(label=_("Precise dating"), required=False)
 
     TYPES = [
-        FieldType('dating_type', models.DatingType),
-        FieldType('quality', models.DatingQuality),
-        FieldType('period', models.Period)
+        FieldType("dating_type", models.DatingType),
+        FieldType("quality", models.DatingQuality),
+        FieldType("period", models.Period),
     ]
 
 
-DatingFormSet = formset_factory(DatingForm, can_delete=True,
-                                formset=FormSet)
+DatingFormSet = formset_factory(DatingForm, can_delete=True, formset=FormSet)
 DatingFormSet.form_label = _("Dating")
 DatingFormSet.form_admin_name = _("Context record - 030 - Dating")
 DatingFormSet.form_slug = "contextrecord-030-datings"
@@ -412,25 +485,29 @@ DatingFormSet.form_slug = "contextrecord-030-datings"
 class RecordRelationsForm(OpeRecordRelationsForm):
     current_model = models.RelationType
     current_related_model = models.ContextRecord
-    associated_models = {'right_record': models.ContextRecord,
-                         'relation_type': models.RelationType}
+    associated_models = {
+        "right_record": models.ContextRecord,
+        "relation_type": models.RelationType,
+    }
     right_record = forms.ChoiceField(
-        label=_("Context record"), choices=[], required=False)
+        label=_("Context record"), choices=[], required=False
+    )
 
     def __init__(self, *args, **kwargs):
         crs = None
-        if 'data' in kwargs and 'CONTEXT_RECORDS' in kwargs['data']:
-            crs = kwargs['data']['CONTEXT_RECORDS']
+        if "data" in kwargs and "CONTEXT_RECORDS" in kwargs["data"]:
+            crs = kwargs["data"]["CONTEXT_RECORDS"]
         super(RecordRelationsForm, self).__init__(*args, **kwargs)
-        self.fields['relation_type'].choices = \
-            models.RelationType.get_types(
-                initial=self.init_data.get('relation_type'))
+        self.fields["relation_type"].choices = models.RelationType.get_types(
+            initial=self.init_data.get("relation_type")
+        )
         if crs:
-            self.fields['right_record'].choices = [('', '-' * 2)] + crs
+            self.fields["right_record"].choices = [("", "-" * 2)] + crs
 
 
 RecordRelationsFormSet = formset_factory(
-    RecordRelationsForm, can_delete=True, formset=RecordRelationsFormSetBase)
+    RecordRelationsForm, can_delete=True, formset=RecordRelationsFormSetBase
+)
 RecordRelationsFormSet.form_label = _("Relations")
 RecordRelationsFormSet.form_admin_name = _("Context record - 050 - Relations")
 RecordRelationsFormSet.form_slug = "contextrecord-050-recordrelations"
@@ -441,36 +518,41 @@ class RecordFormInterpretation(CustomForm, ManageOldType, forms.Form):
     form_admin_name = _("Context record - 040 - Interpretation")
     form_slug = "contextrecord-040-interpretation"
 
-    associated_models = {'activity': models.ActivityType,
-                         'identification': models.IdentificationType}
+    associated_models = {
+        "activity": models.ActivityType,
+        "identification": models.IdentificationType,
+    }
     datings_comment = forms.CharField(
-        label=_("Comments on dating"), required=False,
-        widget=forms.Textarea)
-    filling = forms.CharField(label=_("Filling"),
-                              widget=forms.Textarea, required=False)
-    interpretation = forms.CharField(label=_("Interpretation"),
-                                     widget=forms.Textarea, required=False)
-    activity = forms.ChoiceField(label=_("Activity"), required=False,
-                                 choices=[])
-    identification = forms.ChoiceField(label=_("Identification"),
-                                       required=False, choices=[])
+        label=_("Comments on dating"), required=False, widget=forms.Textarea
+    )
+    filling = forms.CharField(label=_("Filling"), widget=forms.Textarea, required=False)
+    interpretation = forms.CharField(
+        label=_("Interpretation"), widget=forms.Textarea, required=False
+    )
+    activity = forms.ChoiceField(label=_("Activity"), required=False, choices=[])
+    identification = forms.ChoiceField(
+        label=_("Identification"), required=False, choices=[]
+    )
     taq = forms.IntegerField(label=_("TAQ"), required=False)
-    taq_estimated = forms.IntegerField(label=_("Estimated TAQ"),
-                                       required=False)
+    taq_estimated = forms.IntegerField(label=_("Estimated TAQ"), required=False)
     tpq = forms.IntegerField(label=_("TPQ"), required=False)
-    tpq_estimated = forms.IntegerField(label=_("Estimated TPQ"),
-                                       required=False)
+    tpq_estimated = forms.IntegerField(label=_("Estimated TPQ"), required=False)
 
     TYPES = [
-        FieldType('activity', models.ActivityType),
-        FieldType('identification', models.IdentificationType),
+        FieldType("activity", models.ActivityType),
+        FieldType("identification", models.IdentificationType),
     ]
 
 
 OperationRecordFormSelection = get_form_selection(
-    'OperationRecordFormSelection', _("Operation search"), 'operation_id',
-    Operation, OperationSelect, 'get-operation',
-    _("You should select an operation."))
+    "OperationRecordFormSelection",
+    _("Operation search"),
+    "operation_id",
+    Operation,
+    OperationSelect,
+    "get-operation",
+    _("You should select an operation."),
+)
 
 
 class RecordDeletionForm(FinalForm):
@@ -481,30 +563,31 @@ class RecordDeletionForm(FinalForm):
 class QAOperationCR(IshtarForm):
     town = forms.ChoiceField(label=_("Town"), choices=[])
     archaeological_site = forms.ChoiceField(
-        label=" ", choices=[], required=False,
-        help_text=_("Only the items associated to the operation can be "
-                    "selected.")
+        label=" ",
+        choices=[],
+        required=False,
+        help_text=_("Only the items associated to the operation can be " "selected."),
+    )
+    label = forms.CharField(
+        label=_("ID"), validators=[validators.MaxLengthValidator(200)]
     )
-    label = forms.CharField(label=_("ID"),
-                            validators=[validators.MaxLengthValidator(200)])
     parcel = forms.ChoiceField(label=_("Parcel"), choices=[], required=False)
-    unit = forms.ChoiceField(label=_("Context record type"), required=False,
-                             choices=[])
+    unit = forms.ChoiceField(label=_("Context record type"), required=False, choices=[])
 
     TYPES = [
-        FieldType('unit', models.Unit),
+        FieldType("unit", models.Unit),
     ]
 
     def __init__(self, *args, **kwargs):
-        self.items = kwargs.pop('items')
+        self.items = kwargs.pop("items")
         super(QAOperationCR, self).__init__(*args, **kwargs)
         self.profil = IshtarSiteProfile.get_current_profile()
         site_label = self.profil.get_site_label()
-        self.fields['archaeological_site'].label = site_label
-        self.fields['archaeological_site'].choices = [('', '--')]
+        self.fields["archaeological_site"].label = site_label
+        self.fields["archaeological_site"].choices = [("", "--")]
         if self.profil.parcel_mandatory:
-            self.fields['parcel'].required = True
-            self.fields.pop('town')
+            self.fields["parcel"].required = True
+            self.fields.pop("town")
         else:
             self.fields.pop("parcel")
 
@@ -512,31 +595,30 @@ class QAOperationCR(IshtarForm):
             return
         operation = self.items[0]
         if not self.profil.parcel_mandatory:
-            self.fields['town'].choices = [(t.pk, str(t))
-                                           for t in operation.towns.all()]
-        self.fields['archaeological_site'].choices += [
-            (site.pk, str(site))
-            for site in operation.archaeological_sites.all()
+            self.fields["town"].choices = [
+                (t.pk, str(t)) for t in operation.towns.all()
+            ]
+        self.fields["archaeological_site"].choices += [
+            (site.pk, str(site)) for site in operation.archaeological_sites.all()
         ]
         if self.profil.parcel_mandatory:
-            self.fields['parcel'].choices += [('', '--')] + [
-                (str(parcel.pk), "{} - {}".format(parcel.short_label,
-                                                  parcel.town))
-                for parcel in operation.parcels.all()]
+            self.fields["parcel"].choices += [("", "--")] + [
+                (str(parcel.pk), "{} - {}".format(parcel.short_label, parcel.town))
+                for parcel in operation.parcels.all()
+            ]
 
     def save(self, items):
         operation = items[0]
         data = {
             "operation": operation,
-            "archaeological_site_id":
-                self.cleaned_data['archaeological_site'] or None,
-            "label": self.cleaned_data['label'],
-            "unit_id": self.cleaned_data['unit'] or None
+            "archaeological_site_id": self.cleaned_data["archaeological_site"] or None,
+            "label": self.cleaned_data["label"],
+            "unit_id": self.cleaned_data["unit"] or None,
         }
         if self.profil.parcel_mandatory:
-            data["parcel_id"] = self.cleaned_data['parcel']
+            data["parcel_id"] = self.cleaned_data["parcel"]
         else:
-            data["town_id"] = self.cleaned_data['town']
+            data["town_id"] = self.cleaned_data["town"]
         models.ContextRecord.objects.create(**data)
 
 
@@ -544,29 +626,30 @@ class QAContextRecordDuplicateForm(IshtarForm):
     qa_label = forms.CharField(label=_("ID"), max_length=None, required=True)
     qa_parcel = forms.ChoiceField(label=_("Parcel"), choices=[])
     qa_town = forms.ChoiceField(label=_("Town"), choices=[], required=False)
-    qa_unit = forms.ChoiceField(label=_("Context record type"), required=False,
-                                choices=[])
+    qa_unit = forms.ChoiceField(
+        label=_("Context record type"), required=False, choices=[]
+    )
 
     TYPES = [
-        FieldType('qa_unit', models.Unit),
+        FieldType("qa_unit", models.Unit),
     ]
 
     def __init__(self, *args, **kwargs):
         self.user = None
-        if 'user' in kwargs:
-            self.user = kwargs.pop('user')
-            if hasattr(self.user, 'ishtaruser'):
+        if "user" in kwargs:
+            self.user = kwargs.pop("user")
+            if hasattr(self.user, "ishtaruser"):
                 self.user = self.user.ishtaruser
-        self.context_record = kwargs.pop('items')[0]
+        self.context_record = kwargs.pop("items")[0]
         super(QAContextRecordDuplicateForm, self).__init__(*args, **kwargs)
 
         profile = IshtarSiteProfile.get_current_profile()
-        self.fields['qa_parcel'].choices = [('', '--')]
+        self.fields["qa_parcel"].choices = [("", "--")]
         if not profile.parcel_mandatory:
-            self.fields['qa_parcel'].required = False
-            self.fields['qa_town'].choices = [('', '--')]
+            self.fields["qa_parcel"].required = False
+            self.fields["qa_town"].choices = [("", "--")]
         else:
-            self.fields.pop('qa_town')
+            self.fields.pop("qa_town")
 
         get_init_parcel(self, self.context_record.operation, prefix="qa_")
 
@@ -575,8 +658,9 @@ class QAContextRecordDuplicateForm(IshtarForm):
         if "qa_parcel" in self.fields and self.context_record.parcel:
             self.fields["qa_parcel"].initial = self.context_record.parcel.pk
 
-        self.fields['qa_label'].initial = (
-            self.context_record.label or "") + str(_(" - duplicate"))
+        self.fields["qa_label"].initial = (self.context_record.label or "") + str(
+            _(" - duplicate")
+        )
         if self.context_record.unit:
             self.fields["qa_unit"].initial = self.context_record.unit.pk
 
@@ -584,21 +668,21 @@ class QAContextRecordDuplicateForm(IshtarForm):
         data = {"label": self.cleaned_data["qa_label"]}
         if self.cleaned_data.get("qa_unit", None):
             try:
-                data["unit"] = models.Unit.objects.get(pk=int(
-                    self.cleaned_data["qa_unit"]), available=True)
+                data["unit"] = models.Unit.objects.get(
+                    pk=int(self.cleaned_data["qa_unit"]), available=True
+                )
             except models.Unit.DoesNotExist:
                 pass
         if self.cleaned_data.get("qa_town", None):
             try:
-                data["town"] = Town.objects.get(pk=int(
-                    self.cleaned_data["qa_town"]))
+                data["town"] = Town.objects.get(pk=int(self.cleaned_data["qa_town"]))
             except Town.DoesNotExist:
                 pass
         if self.cleaned_data.get("qa_parcel", None):
             try:
-                data["parcel"] = Parcel.objects.get(pk=int(
-                    self.cleaned_data["qa_parcel"]))
+                data["parcel"] = Parcel.objects.get(
+                    pk=int(self.cleaned_data["qa_parcel"])
+                )
             except Parcel.DoesNotExist:
                 pass
-        return self.context_record.duplicate(
-            self.user, data=data)
+        return self.context_record.duplicate(self.user, data=data)
diff --git a/archaeological_context_records/ishtar_menu.py b/archaeological_context_records/ishtar_menu.py
index a7efd8da4..6d4ae1a57 100644
--- a/archaeological_context_records/ishtar_menu.py
+++ b/archaeological_context_records/ishtar_menu.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 # Copyright (C) 2010-2016 Étienne Loks  <etienne.loks_AT_peacefrogsDOTnet>
 
@@ -26,25 +26,45 @@ from . import models
 # be carreful: each access_controls must be relevant with check_rights in urls
 
 MENU_SECTIONS = [
-    (40, SectionItem('record_management', _("Context record"),
-     profile_restriction='context_record',
-     css='menu-context-record',
-     childs=[MenuItem('record_search', _("Search"),
-             model=models.ContextRecord,
-             access_controls=['view_contextrecord',
-                              'view_own_contextrecord']),
-             MenuItem('record_creation', _("Creation"),
-             model=models.ContextRecord,
-             access_controls=['add_contextrecord',
-                              'add_own_contextrecord']),
-             MenuItem('record_modification', _("Modification"),
-             model=models.ContextRecord,
-             access_controls=['change_contextrecord',
-                              'change_own_contextrecord']),
-             MenuItem('record_deletion', _("Deletion"),
-             model=models.ContextRecord,
-             access_controls=['delete_contextrecord',
-                              'delete_own_contextrecord']),
-             ])
-     )
+    (
+        40,
+        SectionItem(
+            "record_management",
+            _("Context record"),
+            profile_restriction="context_record",
+            css="menu-context-record",
+            childs=[
+                MenuItem(
+                    "record_search",
+                    _("Search"),
+                    model=models.ContextRecord,
+                    access_controls=["view_contextrecord", "view_own_contextrecord"],
+                ),
+                MenuItem(
+                    "record_creation",
+                    _("Creation"),
+                    model=models.ContextRecord,
+                    access_controls=["add_contextrecord", "add_own_contextrecord"],
+                ),
+                MenuItem(
+                    "record_modification",
+                    _("Modification"),
+                    model=models.ContextRecord,
+                    access_controls=[
+                        "change_contextrecord",
+                        "change_own_contextrecord",
+                    ],
+                ),
+                MenuItem(
+                    "record_deletion",
+                    _("Deletion"),
+                    model=models.ContextRecord,
+                    access_controls=[
+                        "delete_contextrecord",
+                        "delete_own_contextrecord",
+                    ],
+                ),
+            ],
+        ),
+    )
 ]
diff --git a/archaeological_context_records/lookups.py b/archaeological_context_records/lookups.py
index 7b7d5b85d..3131127d8 100644
--- a/archaeological_context_records/lookups.py
+++ b/archaeological_context_records/lookups.py
@@ -7,19 +7,16 @@ from django.db.models import Q
 from archaeological_context_records import models
 
 
-@register('context_record')
+@register("context_record")
 class ContextRecordLookup(LookupChannel):
     model = models.ContextRecord
 
     def get_query(self, q, request):
         query = Q()
-        for term in q.strip().split(' '):
-            subquery = (
-                Q(cached_label__icontains=term) |
-                Q(town__name__icontains=term)
-            )
+        for term in q.strip().split(" "):
+            subquery = Q(cached_label__icontains=term) | Q(town__name__icontains=term)
             query &= subquery
-        return self.model.objects.filter(query).order_by('cached_label')[:20]
+        return self.model.objects.filter(query).order_by("cached_label")[:20]
 
     def format_item_display(self, item):
         return "<span class='ajax-label'>%s</span>" % item.cached_label
diff --git a/archaeological_context_records/models.py b/archaeological_context_records/models.py
index 2c43ad810..02d488c85 100644
--- a/archaeological_context_records/models.py
+++ b/archaeological_context_records/models.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 # Copyright (C) 2012-2017 Étienne Loks  <etienne.loks_AT_peacefrogsDOTnet>
 
@@ -28,23 +28,47 @@ from django.core.urlresolvers import reverse
 from django.db import connection
 from django.db.models import Q
 from django.db.models.signals import post_delete, post_save, m2m_changed
-from ishtar_common.utils import ugettext_lazy as _,\
-    pgettext_lazy, pgettext
+from ishtar_common.utils import ugettext_lazy as _, pgettext_lazy, pgettext
 from django.utils.text import slugify
 
-from ishtar_common.utils import cached_label_changed, \
-    m2m_historization_changed, post_save_geo
-
-from ishtar_common.models import Document, GeneralType, \
-    BaseHistorizedItem, OwnPerms, ShortMenuItem, \
-    GeneralRelationType, GeneralRecordRelations, post_delete_record_relation,\
-    post_save_cache, ValueGetter, BulkUpdatedItem, \
-    RelationItem, Town, get_current_profile, document_attached_changed, \
-    HistoryModel, SearchAltName, GeoItem, CompleteIdentifierItem, SearchVectorConfig, \
-    DocumentItem, MainItem, QuickAction
+from ishtar_common.utils import (
+    cached_label_changed,
+    m2m_historization_changed,
+    post_save_geo,
+)
+
+from ishtar_common.models import (
+    Document,
+    GeneralType,
+    BaseHistorizedItem,
+    OwnPerms,
+    ShortMenuItem,
+    GeneralRelationType,
+    GeneralRecordRelations,
+    post_delete_record_relation,
+    post_save_cache,
+    ValueGetter,
+    BulkUpdatedItem,
+    RelationItem,
+    Town,
+    get_current_profile,
+    document_attached_changed,
+    HistoryModel,
+    SearchAltName,
+    GeoItem,
+    CompleteIdentifierItem,
+    SearchVectorConfig,
+    DocumentItem,
+    MainItem,
+    QuickAction,
+)
 from ishtar_common.models_common import HistoricalRecords
-from archaeological_operations.models import Operation, Period, Parcel, \
-    ArchaeologicalSite
+from archaeological_operations.models import (
+    Operation,
+    Period,
+    Parcel,
+    ArchaeologicalSite,
+)
 from ishtar_common.model_managers import UUIDModelManager
 
 
@@ -52,7 +76,7 @@ class DatingType(GeneralType):
     class Meta:
         verbose_name = _("Dating type")
         verbose_name_plural = _("Dating types")
-        ordering = ('label',)
+        ordering = ("label",)
 
 
 post_save.connect(post_save_cache, sender=DatingType)
@@ -63,7 +87,7 @@ class DatingQuality(GeneralType):
     class Meta:
         verbose_name = _("Dating quality type")
         verbose_name_plural = _("Dating quality types")
-        ordering = ('label',)
+        ordering = ("label",)
 
 
 post_save.connect(post_save_cache, sender=DatingQuality)
@@ -75,48 +99,55 @@ class Dating(models.Model):
     period = models.ForeignKey(Period, verbose_name=_("Period"))
     start_date = models.IntegerField(_("Start date"), blank=True, null=True)
     end_date = models.IntegerField(_("End date"), blank=True, null=True)
-    dating_type = models.ForeignKey(DatingType, verbose_name=_("Dating type"),
-                                    on_delete=models.SET_NULL,
-                                    blank=True, null=True)
-    quality = models.ForeignKey(DatingQuality, verbose_name=_("Quality"),
-                                on_delete=models.SET_NULL,
-                                blank=True, null=True)
-    precise_dating = models.TextField(
-        _("Precise dating"), blank=True, default="")
+    dating_type = models.ForeignKey(
+        DatingType,
+        verbose_name=_("Dating type"),
+        on_delete=models.SET_NULL,
+        blank=True,
+        null=True,
+    )
+    quality = models.ForeignKey(
+        DatingQuality,
+        verbose_name=_("Quality"),
+        on_delete=models.SET_NULL,
+        blank=True,
+        null=True,
+    )
+    precise_dating = models.TextField(_("Precise dating"), blank=True, default="")
     objects = UUIDModelManager()
     ASSOCIATED_ALT_NAMES = {
-        'datings__period': SearchAltName(
+        "datings__period": SearchAltName(
             pgettext_lazy("key for text search", "datings-period"),
-            'datings__period__label__iexact'
+            "datings__period__label__iexact",
         ),
         "datings__precise_dating": SearchAltName(
             pgettext_lazy("key for text search", "datings-precise"),
-            'datings__precise_dating__iexact'
+            "datings__precise_dating__iexact",
         ),
         "datings__start_date__before": SearchAltName(
             pgettext_lazy("key for text search", "datings-start-before"),
-            'datings__start_date__lte'
+            "datings__start_date__lte",
         ),
         "datings__start_date__after": SearchAltName(
             pgettext_lazy("key for text search", "datings-start-after"),
-            'datings__start_date__gte'
+            "datings__start_date__gte",
         ),
         "datings__end_date__before": SearchAltName(
             pgettext_lazy("key for text search", "datings-end-before"),
-            'datings__end_date__lte'
+            "datings__end_date__lte",
         ),
         "datings__end_date__after": SearchAltName(
             pgettext_lazy("key for text search", "datings-end-after"),
-            'datings__end_date__gte'
+            "datings__end_date__gte",
         ),
         "datings__dating_type": SearchAltName(
             pgettext_lazy("key for text search", "datings-type"),
-            'datings__dating_type__label__iexact'
+            "datings__dating_type__label__iexact",
         ),
         "datings__quality": SearchAltName(
             pgettext_lazy("key for text search", "datings-quality"),
-            'datings__quality__label__iexact'
-        )
+            "datings__quality__label__iexact",
+        ),
     }
 
     class Meta:
@@ -133,39 +164,45 @@ class Dating(models.Model):
         return "%s (%s-%s)" % (self.period, start_date, end_date)
 
     def natural_key(self):
-        return self.uuid,
+        return (self.uuid,)
 
-    def get_values(self, prefix='', no_values=False, filtr=None, **kwargs):
+    def get_values(self, prefix="", no_values=False, filtr=None, **kwargs):
         values = {}
         if not filtr or prefix + "period" in filtr:
             values[prefix + "period"] = str(self.period)
         if not filtr or prefix + "start_date" in filtr:
-            values[prefix + "start_date"] = self.start_date or ''
+            values[prefix + "start_date"] = self.start_date or ""
         if not filtr or prefix + "end_date" in filtr:
-            values[prefix + "end_date"] = self.end_date or ''
+            values[prefix + "end_date"] = self.end_date or ""
         if not filtr or prefix + "dating_type" in filtr:
-            values[prefix + "dating_type"] = \
+            values[prefix + "dating_type"] = (
                 str(self.dating_type) if self.dating_type else ""
+            )
         if not filtr or prefix + "quality" in filtr:
-            values[prefix + "quality"] = \
-                str(self.quality) if self.quality else ""
+            values[prefix + "quality"] = str(self.quality) if self.quality else ""
         if not filtr or prefix + "precise_dating" in filtr:
             values[prefix + "precise_dating"] = self.precise_dating
         return values
 
-    HISTORY_ATTR = ["period", "start_date", "end_date", "dating_type",
-                    "quality", "precise_dating"]
+    HISTORY_ATTR = [
+        "period",
+        "start_date",
+        "end_date",
+        "dating_type",
+        "quality",
+        "precise_dating",
+    ]
 
     def history_compress(self):
         values = {}
         for attr in self.HISTORY_ATTR:
             val = getattr(self, attr)
-            if hasattr(val, 'history_compress'):
+            if hasattr(val, "history_compress"):
                 val = val.history_compress()
-            elif hasattr(val, 'isoformat'):
+            elif hasattr(val, "isoformat"):
                 val = val.isoformat()
             elif val is None:
-                val = ''
+                val = ""
             else:
                 val = str(val)
             values[attr] = val
@@ -180,7 +217,7 @@ class Dating(models.Model):
             res = {}
             for key in value:
                 val = value[key]
-                if val == '' and key != "precise_dating":
+                if val == "" and key != "precise_dating":
                     val = None
                 elif key in ("period", "dating_type", "quality"):
                     field = cls._meta.get_field(key)
@@ -203,8 +240,14 @@ class Dating(models.Model):
         Compare two dating attribute by attribute and return True if all
         attribute is identical
         """
-        for attr in ["period", "start_date", "end_date", "dating_type",
-                     "quality", "precise_dating"]:
+        for attr in [
+            "period",
+            "start_date",
+            "end_date",
+            "dating_type",
+            "quality",
+            "precise_dating",
+        ]:
             value1 = getattr(dating_1, attr)
             value2 = getattr(dating_2, attr)
             if attr == "precise_dating":
@@ -218,11 +261,13 @@ class Dating(models.Model):
 
     def context_records_lbl(self):
         return " - ".join(cr.cached_label for cr in self.context_records.all())
+
     context_records_lbl.short_description = _("Context record")
     context_records_lbl.admin_order_field = "context_records__cached_label"
 
     def finds_lbl(self):
         return " - ".join(f.cached_label for f in self.find.all())
+
     finds_lbl.short_description = _("Find")
     finds_lbl.admin_order_field = "find__cached_label"
 
@@ -232,9 +277,15 @@ class Dating(models.Model):
         Fix redundant m2m dating association (usually after imports)
         """
         current_datings = []
-        for dating in obj.datings.order_by('pk').all():
-            key = (dating.period.pk, dating.start_date, dating.end_date,
-                   dating.dating_type, dating.quality, dating.precise_dating)
+        for dating in obj.datings.order_by("pk").all():
+            key = (
+                dating.period.pk,
+                dating.start_date,
+                dating.end_date,
+                dating.dating_type,
+                dating.quality,
+                dating.precise_dating,
+            )
             if key not in current_datings:
                 current_datings.append(key)
                 continue
@@ -244,13 +295,17 @@ class Dating(models.Model):
 class Unit(GeneralType):
     order = models.IntegerField(_("Order"))
     parent = models.ForeignKey(
-        "Unit", verbose_name=_("Parent context record type"),
-        on_delete=models.SET_NULL, blank=True, null=True)
+        "Unit",
+        verbose_name=_("Parent context record type"),
+        on_delete=models.SET_NULL,
+        blank=True,
+        null=True,
+    )
 
     class Meta:
         verbose_name = _("Context record Type")
         verbose_name_plural = _("Context record Types")
-        ordering = ('order', 'label')
+        ordering = ("order", "label")
 
     def __str__(self):
         return self.label
@@ -266,7 +321,7 @@ class ActivityType(GeneralType):
     class Meta:
         verbose_name = _("Activity Type")
         verbose_name_plural = _("Activity Types")
-        ordering = ('order',)
+        ordering = ("order",)
 
     def __str__(self):
         return self.label
@@ -282,7 +337,7 @@ class IdentificationType(GeneralType):
     class Meta:
         verbose_name = _("Identification Type")
         verbose_name_plural = _("Identification Types")
-        ordering = ('order', 'label')
+        ordering = ("order", "label")
 
     def __str__(self):
         return self.label
@@ -296,7 +351,7 @@ class ExcavationTechnicType(GeneralType):
     class Meta:
         verbose_name = _("Excavation technique type")
         verbose_name_plural = _("Excavation technique types")
-        ordering = ('label',)
+        ordering = ("label",)
 
 
 post_save.connect(post_save_cache, sender=ExcavationTechnicType)
@@ -307,7 +362,7 @@ class DocumentationType(GeneralType):
     class Meta:
         verbose_name = _("Documentation type")
         verbose_name_plural = _("Documentation types")
-        ordering = ('label',)
+        ordering = ("label",)
 
 
 post_save.connect(post_save_cache, sender=DocumentationType)
@@ -334,138 +389,152 @@ class CRBulkView(object):
     """
 
 
-class ContextRecord(BulkUpdatedItem, DocumentItem, BaseHistorizedItem,
-                    CompleteIdentifierItem, GeoItem, OwnPerms, ValueGetter, MainItem,
-                    RelationItem):
-    SLUG = 'contextrecord'
+class ContextRecord(
+    BulkUpdatedItem,
+    DocumentItem,
+    BaseHistorizedItem,
+    CompleteIdentifierItem,
+    GeoItem,
+    OwnPerms,
+    ValueGetter,
+    MainItem,
+    RelationItem,
+):
+    SLUG = "contextrecord"
     APP = "archaeological-context-records"
     MODEL = "context-record"
-    SHOW_URL = 'show-contextrecord'
-    DELETE_URL = 'delete-contextrecord'
-    EXTERNAL_ID_KEY = 'context_record_external_id'
-    EXTERNAL_ID_DEPENDENCIES = ['base_finds']
-    TABLE_COLS = ['label', 'operation__common_name', 'town__name',
-                  'parcel__cached_label', 'unit__label']
-    if settings.COUNTRY == 'fr':
-        TABLE_COLS.insert(1, 'operation__code_patriarche')
-    TABLE_COLS_FOR_OPE = ['label', 'parcel__cached_label', 'unit__label',
-                          'cached_periods', 'description']
+    SHOW_URL = "show-contextrecord"
+    DELETE_URL = "delete-contextrecord"
+    EXTERNAL_ID_KEY = "context_record_external_id"
+    EXTERNAL_ID_DEPENDENCIES = ["base_finds"]
+    TABLE_COLS = [
+        "label",
+        "operation__common_name",
+        "town__name",
+        "parcel__cached_label",
+        "unit__label",
+    ]
+    if settings.COUNTRY == "fr":
+        TABLE_COLS.insert(1, "operation__code_patriarche")
+    TABLE_COLS_FOR_OPE = [
+        "label",
+        "parcel__cached_label",
+        "unit__label",
+        "cached_periods",
+        "description",
+    ]
     NEW_QUERY_ENGINE = True
     COL_LABELS = {
-        'cached_periods': _("Periods"),
-        'datings__period__label': _("Periods"),
-        'datings__period': _("Datings (period)"),
-        'detailed_related_context_records': _("Related context records"),
+        "cached_periods": _("Periods"),
+        "datings__period__label": _("Periods"),
+        "datings__period": _("Datings (period)"),
+        "detailed_related_context_records": _("Related context records"),
         "cached_related_context_records": _("Related context records"),
-        'operation__code_patriarche': _("Operation (Patriarche code)"),
-        'operation__common_name': _("Operation (name)"),
-        'parcel__external_id': _("Parcel (external ID)"),
-        'town__name': _("Town"),
-        'town': _("Town"),
-        'parcel__year': _("Parcel (year)"),
-        'section__parcel_number': _("Parcel"),
-        'parcel__cached_label': _("Parcel"),
-        'unit__label': _("Context record type"),
+        "operation__code_patriarche": _("Operation (Patriarche code)"),
+        "operation__common_name": _("Operation (name)"),
+        "parcel__external_id": _("Parcel (external ID)"),
+        "town__name": _("Town"),
+        "town": _("Town"),
+        "parcel__year": _("Parcel (year)"),
+        "section__parcel_number": _("Parcel"),
+        "parcel__cached_label": _("Parcel"),
+        "unit__label": _("Context record type"),
     }
     CONTEXTUAL_TABLE_COLS = {
-        'full': {
-            'related_context_records': 'cached_related_context_records'
-        }
+        "full": {"related_context_records": "cached_related_context_records"}
     }
     # statistics
-    STATISTIC_MODALITIES_OPTIONS = OrderedDict([
-        ("unit__label", _("Context record type")),
-        ("datings__period__label", _("Period")),
-        ("identification__label", _("Identification")),
-        ("activity__label", _("Activity")),
-        ("excavation_technic__label", _("Excavation technique")),
-        ("documents__source_type__label", _("Associated document type")),
-    ])
-    STATISTIC_MODALITIES = [
-        key for key, lbl in STATISTIC_MODALITIES_OPTIONS.items()]
+    STATISTIC_MODALITIES_OPTIONS = OrderedDict(
+        [
+            ("unit__label", _("Context record type")),
+            ("datings__period__label", _("Period")),
+            ("identification__label", _("Identification")),
+            ("activity__label", _("Activity")),
+            ("excavation_technic__label", _("Excavation technique")),
+            ("documents__source_type__label", _("Associated document type")),
+        ]
+    )
+    STATISTIC_MODALITIES = [key for key, lbl in STATISTIC_MODALITIES_OPTIONS.items()]
 
     # search parameters
     EXTRA_REQUEST_KEYS = {
-        'town': 'town__pk',
-        'town__name': 'town__name',
-        'parcel__cached_label': 'parcel__cached_label',
-        'operation__year': 'operation__year__contains',
-        'year': 'operation__year__contains',
-        'operation__code_patriarche': 'operation__code_patriarche',
-        'operation__operation_code': 'operation__operation_code',
-        'operation__common_name': 'operation__common_name',
-        'datings__period': 'datings__period__pk',
-        'parcel_0': 'operation__parcels__section',
-        'parcel_1': 'operation__parcels__parcel_number',
-        'parcel_2': 'operation__parcels__public_domain',
-        'label': 'label__icontains',
-        'archaeological_sites': 'operation__archaeological_sites__pk',
-        'cached_label': 'cached_label__icontains',
-        'datings__period__label': 'datings__period__label',
-        'operation_id': 'operation_id',
-        'unit__label': "unit__label",
+        "town": "town__pk",
+        "town__name": "town__name",
+        "parcel__cached_label": "parcel__cached_label",
+        "operation__year": "operation__year__contains",
+        "year": "operation__year__contains",
+        "operation__code_patriarche": "operation__code_patriarche",
+        "operation__operation_code": "operation__operation_code",
+        "operation__common_name": "operation__common_name",
+        "datings__period": "datings__period__pk",
+        "parcel_0": "operation__parcels__section",
+        "parcel_1": "operation__parcels__parcel_number",
+        "parcel_2": "operation__parcels__public_domain",
+        "label": "label__icontains",
+        "archaeological_sites": "operation__archaeological_sites__pk",
+        "cached_label": "cached_label__icontains",
+        "datings__period__label": "datings__period__label",
+        "operation_id": "operation_id",
+        "unit__label": "unit__label",
     }
-    MANY_COUNTED_FIELDS = ['base_finds']
+    MANY_COUNTED_FIELDS = ["base_finds"]
     REVERSED_BOOL_FIELDS = [
-        'documents__image__isnull',
-        'documents__associated_file__isnull',
-        'documents__associated_url__isnull',
+        "documents__image__isnull",
+        "documents__associated_file__isnull",
+        "documents__associated_url__isnull",
     ]
-    RELATION_TYPES_PREFIX = {'ope_relation_types': 'operation__',
-                             'cr_relation_types': ''}
+    RELATION_TYPES_PREFIX = {
+        "ope_relation_types": "operation__",
+        "cr_relation_types": "",
+    }
     # alternative names of fields for searches
     ALT_NAMES = {
-        'label': SearchAltName(
-            pgettext_lazy("key for text search", "id"),
-            'label__iexact'
+        "label": SearchAltName(
+            pgettext_lazy("key for text search", "id"), "label__iexact"
         ),
-        'town': SearchAltName(
-            pgettext_lazy("key for text search", "town"),
-            'town__cached_label__iexact'
+        "town": SearchAltName(
+            pgettext_lazy("key for text search", "town"), "town__cached_label__iexact"
         ),
-        'operation__year': SearchAltName(
-            pgettext_lazy("key for text search", "operation-year"),
-            'operation__year'
+        "operation__year": SearchAltName(
+            pgettext_lazy("key for text search", "operation-year"), "operation__year"
         ),
-        'operation__code_patriarche': SearchAltName(
+        "operation__code_patriarche": SearchAltName(
             pgettext_lazy("key for text search", "patriarche"),
-            'operation__code_patriarche__iexact'
+            "operation__code_patriarche__iexact",
         ),
-        'operation__operation_code': SearchAltName(
+        "operation__operation_code": SearchAltName(
             pgettext_lazy("key for text search", "operation-code"),
-            'operation__operation_code'
+            "operation__operation_code",
         ),
-        'operation__cached_label': SearchAltName(
+        "operation__cached_label": SearchAltName(
             pgettext_lazy("key for text search", "operation"),
-            'operation__cached_label__icontains'
+            "operation__cached_label__icontains",
         ),
-        'archaeological_site': SearchAltName(
+        "archaeological_site": SearchAltName(
             pgettext_lazy("key for text search", "site"),
-            'archaeological_site__cached_label__icontains'
+            "archaeological_site__cached_label__icontains",
         ),
-        'ope_relation_types': SearchAltName(
+        "ope_relation_types": SearchAltName(
             pgettext_lazy("key for text search", "operation-relation-type"),
-            'ope_relation_types'
+            "ope_relation_types",
         ),
-        'datings__period': SearchAltName(
+        "datings__period": SearchAltName(
             pgettext_lazy("key for text search", "period"),
-            'datings__period__label__iexact'
+            "datings__period__label__iexact",
         ),
-        'unit': SearchAltName(
-            pgettext_lazy("key for text search", "unit-type"),
-            'unit__label__iexact'
+        "unit": SearchAltName(
+            pgettext_lazy("key for text search", "unit-type"), "unit__label__iexact"
         ),
-        'parcel': SearchAltName(
+        "parcel": SearchAltName(
             pgettext_lazy("key for text search", "parcel"),
-            'parcel__cached_label__iexact'
+            "parcel__cached_label__iexact",
         ),
-        'has_finds': SearchAltName(
-            pgettext_lazy("key for text search", "has-finds"),
-            'base_finds'
+        "has_finds": SearchAltName(
+            pgettext_lazy("key for text search", "has-finds"), "base_finds"
         ),
-        'cr_relation_types': SearchAltName(
+        "cr_relation_types": SearchAltName(
             pgettext_lazy("key for text search", "record-relation-type"),
-            'cr_relation_types'
+            "cr_relation_types",
         ),
     }
     ALT_NAMES.update(BaseHistorizedItem.ALT_NAMES)
@@ -478,47 +547,47 @@ class ContextRecord(BulkUpdatedItem, DocumentItem, BaseHistorizedItem,
         SearchVectorConfig("label"),
         SearchVectorConfig("location"),
         SearchVectorConfig("town__name"),
-        SearchVectorConfig("interpretation", 'local'),
-        SearchVectorConfig("filling", 'local'),
-        SearchVectorConfig("datings_comment", 'local'),
+        SearchVectorConfig("interpretation", "local"),
+        SearchVectorConfig("filling", "local"),
+        SearchVectorConfig("datings_comment", "local"),
         SearchVectorConfig("identification__label"),
         SearchVectorConfig("activity__label"),
-        SearchVectorConfig("excavation_technic__label")]
-    M2M_SEARCH_VECTORS = [
-        SearchVectorConfig("datings__period__label", 'local')
+        SearchVectorConfig("excavation_technic__label"),
     ]
+    M2M_SEARCH_VECTORS = [SearchVectorConfig("datings__period__label", "local")]
     UP_MODEL_QUERY = {
         "operation": (
             pgettext_lazy("key for text search", "operation"),
-            'cached_label'),
-        "site": (
-            pgettext_lazy("key for text search", "site"),
-            'cached_label'),
+            "cached_label",
+        ),
+        "site": (pgettext_lazy("key for text search", "site"), "cached_label"),
     }
     MAIN_UP_MODEL_QUERY = "operation"
     RELATIVE_SESSION_NAMES = [
-        ('operation', 'operation__pk'),
-        ('site', 'archaeological_site__pk'),
-        ('file', 'operation__associated_file__pk'),
-    ]
-    HISTORICAL_M2M = [
-        'datings', 'documentations'
+        ("operation", "operation__pk"),
+        ("site", "archaeological_site__pk"),
+        ("file", "operation__associated_file__pk"),
     ]
-    CACHED_LABELS = ['cached_label', 'cached_periods',
-                     "cached_related_context_records"]
+    HISTORICAL_M2M = ["datings", "documentations"]
+    CACHED_LABELS = ["cached_label", "cached_periods", "cached_related_context_records"]
     DOWN_MODEL_UPDATE = ["base_finds"]
 
     QA_LOCK = QuickAction(
-        url="contextrecord-qa-lock", icon_class="fa fa-lock",
-        text=_("Lock/Unlock"), target="many",
-        rights=['change_contextrecord', 'change_own_contextrecord']
+        url="contextrecord-qa-lock",
+        icon_class="fa fa-lock",
+        text=_("Lock/Unlock"),
+        target="many",
+        rights=["change_contextrecord", "change_own_contextrecord"],
     )
     QUICK_ACTIONS = [
         QA_LOCK,
         QuickAction(
-            url="contextrecord-qa-duplicate", icon_class="fa fa-clone",
-            text=_("Duplicate"), target="one",
-            rights=['change_contextrecord', 'change_own_contextrecord']),
+            url="contextrecord-qa-duplicate",
+            icon_class="fa fa-clone",
+            text=_("Duplicate"),
+            target="one",
+            rights=["change_contextrecord", "change_own_contextrecord"],
+        ),
     ]
 
     history = HistoricalRecords(bases=[HistoryModel])
@@ -528,91 +597,150 @@ class ContextRecord(BulkUpdatedItem, DocumentItem, BaseHistorizedItem,
     uuid = models.UUIDField(default=uuid.uuid4)
     external_id = models.TextField(_("External ID"), blank=True, default="")
     auto_external_id = models.BooleanField(
-        _("External ID is set automatically"), default=False)
+        _("External ID is set automatically"), default=False
+    )
     parcel = models.ForeignKey(
-        Parcel, verbose_name=_("Parcel"), related_name='context_record',
-        on_delete=models.SET_NULL, blank=True, null=True)
+        Parcel,
+        verbose_name=_("Parcel"),
+        related_name="context_record",
+        on_delete=models.SET_NULL,
+        blank=True,
+        null=True,
+    )
     town = models.ForeignKey(
-        Town, verbose_name=_("Town"), related_name='context_record',
-        on_delete=models.SET_NULL, blank=True, null=True)
-    operation = models.ForeignKey(Operation, verbose_name=_("Operation"),
-                                  related_name='context_record')
+        Town,
+        verbose_name=_("Town"),
+        related_name="context_record",
+        on_delete=models.SET_NULL,
+        blank=True,
+        null=True,
+    )
+    operation = models.ForeignKey(
+        Operation, verbose_name=_("Operation"), related_name="context_record"
+    )
     archaeological_site = models.ForeignKey(
-        ArchaeologicalSite, verbose_name=_("Archaeological site"),
+        ArchaeologicalSite,
+        verbose_name=_("Archaeological site"),
         on_delete=models.SET_NULL,
-        blank=True, null=True, related_name='context_records')
+        blank=True,
+        null=True,
+        related_name="context_records",
+    )
     label = models.CharField(_("ID"), max_length=200)
     description = models.TextField(_("Description"), blank=True, default="")
     comment = models.TextField(_("General comment"), blank=True, default="")
-    opening_date = models.DateField(_("Opening date"),
-                                    blank=True, null=True)
+    opening_date = models.DateField(_("Opening date"), blank=True, null=True)
     closing_date = models.DateField(_("Closing date"), blank=True, null=True)
     length = models.FloatField(_("Length (m)"), blank=True, null=True)
     width = models.FloatField(_("Width (m)"), blank=True, null=True)
-    thickness = models.FloatField(_("Thickness (m)"), blank=True,
-                                  null=True)
+    thickness = models.FloatField(_("Thickness (m)"), blank=True, null=True)
     diameter = models.FloatField(_("Diameter (m)"), blank=True, null=True)
     depth = models.FloatField(_("Depth (m)"), blank=True, null=True)
     depth_of_appearance = models.FloatField(
-        _("Depth of appearance (m)"), blank=True, null=True)
+        _("Depth of appearance (m)"), blank=True, null=True
+    )
     surface = models.IntegerField(_("Surface (m2)"), blank=True, null=True)
     location = models.TextField(
-        _("Location"), blank=True, default="",
-        help_text=_("A short description of the location of the context "
-                    "record"))
-    datings = models.ManyToManyField(Dating, related_name='context_records')
+        _("Location"),
+        blank=True,
+        default="",
+        help_text=_("A short description of the location of the context " "record"),
+    )
+    datings = models.ManyToManyField(Dating, related_name="context_records")
     documentations = models.ManyToManyField(DocumentationType, blank=True)
-    datings_comment = models.TextField(
-        _("Comment on datings"), blank=True, default="")
-    unit = models.ForeignKey(Unit, verbose_name=_("Context record type"),
-                             on_delete=models.SET_NULL,
-                             related_name='+', blank=True, null=True)
+    datings_comment = models.TextField(_("Comment on datings"), blank=True, default="")
+    unit = models.ForeignKey(
+        Unit,
+        verbose_name=_("Context record type"),
+        on_delete=models.SET_NULL,
+        related_name="+",
+        blank=True,
+        null=True,
+    )
     filling = models.TextField(_("Filling"), blank=True, default="")
-    interpretation = models.TextField(
-        _("Interpretation"), blank=True, default="")
+    interpretation = models.TextField(_("Interpretation"), blank=True, default="")
     taq = models.IntegerField(
-        _("TAQ"), blank=True, null=True,
-        help_text=_("\"Terminus Ante Quem\" the context record can't have "
-                    "been created after this date"))
+        _("TAQ"),
+        blank=True,
+        null=True,
+        help_text=_(
+            '"Terminus Ante Quem" the context record can\'t have '
+            "been created after this date"
+        ),
+    )
     taq_estimated = models.IntegerField(
-        _("Estimated TAQ"), blank=True, null=True,
-        help_text=_("Estimation of a \"Terminus Ante Quem\""))
+        _("Estimated TAQ"),
+        blank=True,
+        null=True,
+        help_text=_('Estimation of a "Terminus Ante Quem"'),
+    )
     tpq = models.IntegerField(
-        _("TPQ"), blank=True, null=True,
-        help_text=_("\"Terminus Post Quem\" the context record can't have "
-                    "been created before this date"))
+        _("TPQ"),
+        blank=True,
+        null=True,
+        help_text=_(
+            '"Terminus Post Quem" the context record can\'t have '
+            "been created before this date"
+        ),
+    )
     tpq_estimated = models.IntegerField(
-        _("Estimated TPQ"), blank=True, null=True,
-        help_text=_("Estimation of a \"Terminus Post Quem\""))
+        _("Estimated TPQ"),
+        blank=True,
+        null=True,
+        help_text=_('Estimation of a "Terminus Post Quem"'),
+    )
     identification = models.ForeignKey(
-        IdentificationType, blank=True, null=True,
+        IdentificationType,
+        blank=True,
+        null=True,
         on_delete=models.SET_NULL,
-        verbose_name=_("Identification"),)
-    activity = models.ForeignKey(ActivityType, blank=True, null=True,
-                                 on_delete=models.SET_NULL,
-                                 verbose_name=_("Activity"),)
+        verbose_name=_("Identification"),
+    )
+    activity = models.ForeignKey(
+        ActivityType,
+        blank=True,
+        null=True,
+        on_delete=models.SET_NULL,
+        verbose_name=_("Activity"),
+    )
     excavation_technic = models.ForeignKey(
-        ExcavationTechnicType, blank=True, null=True,
+        ExcavationTechnicType,
+        blank=True,
+        null=True,
         on_delete=models.SET_NULL,
-        verbose_name=_("Excavation technique"))
+        verbose_name=_("Excavation technique"),
+    )
     related_context_records = models.ManyToManyField(
-        'ContextRecord', through='RecordRelations', blank=True)
+        "ContextRecord", through="RecordRelations", blank=True
+    )
     documents = models.ManyToManyField(
-        Document, related_name='context_records', verbose_name=_("Documents"),
-        blank=True)
+        Document,
+        related_name="context_records",
+        verbose_name=_("Documents"),
+        blank=True,
+    )
     main_image = models.ForeignKey(
-        Document, related_name='main_image_context_records',
+        Document,
+        related_name="main_image_context_records",
         on_delete=models.SET_NULL,
-        verbose_name=_("Main image"), blank=True, null=True)
-    cached_label = models.TextField(_("Cached name"), blank=True, default="",
-                                    db_index=True)
-    cached_periods =  models.TextField(
-        _("Cached periods label"), blank=True, default="",
-        help_text=_("Generated automatically - do not edit")
+        verbose_name=_("Main image"),
+        blank=True,
+        null=True,
+    )
+    cached_label = models.TextField(
+        _("Cached name"), blank=True, default="", db_index=True
+    )
+    cached_periods = models.TextField(
+        _("Cached periods label"),
+        blank=True,
+        default="",
+        help_text=_("Generated automatically - do not edit"),
     )
     cached_related_context_records = models.TextField(
-        _("Cached related context records"), blank=True, default="",
-        help_text=_("Generated automatically - do not edit")
+        _("Cached related context records"),
+        blank=True,
+        default="",
+        help_text=_("Generated automatically - do not edit"),
     )
 
     class Meta:
@@ -625,13 +753,13 @@ class ContextRecord(BulkUpdatedItem, DocumentItem, BaseHistorizedItem,
             ("change_own_contextrecord", "Can change own Context Record"),
             ("delete_own_contextrecord", "Can delete own Context Record"),
         )
-        ordering = ('cached_label',)
+        ordering = ("cached_label",)
         indexes = [
-            GinIndex(fields=['data']),
+            GinIndex(fields=["data"]),
         ]
 
     def natural_key(self):
-        return (self.uuid, )
+        return (self.uuid,)
 
     @property
     def name(self):
@@ -651,36 +779,39 @@ class ContextRecord(BulkUpdatedItem, DocumentItem, BaseHistorizedItem,
 
     def public_representation(self):
         dct = super(ContextRecord, self).public_representation()
-        dct.update({
-            "operation": self.operation.public_representation(),
-            "site": self.archaeological_site and
-                    self.archaeological_site.public_representation(),
-            "parcel": str(self.parcel),
-            "town": self.town.label_with_areas if self.town else None,
-            "label": self.label,
-            "description": self.description,
-            "comment": self.comment
-        })
+        dct.update(
+            {
+                "operation": self.operation.public_representation(),
+                "site": self.archaeological_site
+                and self.archaeological_site.public_representation(),
+                "parcel": str(self.parcel),
+                "town": self.town.label_with_areas if self.town else None,
+                "label": self.label,
+                "description": self.description,
+                "comment": self.comment,
+            }
+        )
         return dct
 
     DOC_VALUES = [
         ("base_finds", _("List of associated base finds")),
     ]
 
-    def get_values(self, prefix='', no_values=False, filtr=None, **kwargs):
+    def get_values(self, prefix="", no_values=False, filtr=None, **kwargs):
         no_base_finds = True
         if "no_base_finds" in kwargs:
             no_base_finds = kwargs["no_base_finds"]
         values = super(ContextRecord, self).get_values(
-            prefix=prefix, no_values=no_values, filtr=filtr, **kwargs)
+            prefix=prefix, no_values=no_values, filtr=filtr, **kwargs
+        )
         if prefix and no_base_finds:
             return values
 
-        if not filtr or prefix + 'base_finds' in filtr:
-            values[prefix + 'base_finds'] = [
-                bf.get_values(
-                    prefix=prefix, no_values=True, filtr=None, **kwargs)
-                for bf in self.base_finds.distinct().all()]
+        if not filtr or prefix + "base_finds" in filtr:
+            values[prefix + "base_finds"] = [
+                bf.get_values(prefix=prefix, no_values=True, filtr=None, **kwargs)
+                for bf in self.base_finds.distinct().all()
+            ]
         return values
 
     def get_town_centroid(self):
@@ -722,24 +853,26 @@ class ContextRecord(BulkUpdatedItem, DocumentItem, BaseHistorizedItem,
         return self.operation.get_precise_polygons()
 
     @classmethod
-    def cached_label_bulk_update(cls, operation_id=None, parcel_id=None,
-                                 transaction_id=None):
+    def cached_label_bulk_update(
+        cls, operation_id=None, parcel_id=None, transaction_id=None
+    ):
         transaction_id, is_recursion = cls.bulk_recursion(
-            transaction_id, [operation_id, parcel_id])
+            transaction_id, [operation_id, parcel_id]
+        )
         if is_recursion:
             return
 
         if operation_id:
             where = "operation_id = %s"
             args = [int(operation_id)]
-            kwargs = {'operation_id': operation_id}
+            kwargs = {"operation_id": operation_id}
         elif parcel_id:
             where = "parcel_id = %s"
             args = [int(parcel_id)]
-            kwargs = {'parcel_id': parcel_id}
+            kwargs = {"parcel_id": parcel_id}
         else:
             return
-        kwargs['transaction_id'] = transaction_id
+        kwargs["transaction_id"] = transaction_id
 
         profile = get_current_profile()
 
@@ -776,18 +909,27 @@ class ContextRecord(BulkUpdatedItem, DocumentItem, BaseHistorizedItem,
                 SELECT id FROM archaeological_context_records_contextrecord
                 WHERE {where}
             );
-        """.format(main_ope_prefix=profile.operation_prefix,
-                   ope_prefix=profile.default_operation_prefix,
-                   join=settings.JOINT, where=where)
+        """.format(
+            main_ope_prefix=profile.operation_prefix,
+            ope_prefix=profile.default_operation_prefix,
+            join=settings.JOINT,
+            where=where,
+        )
         with connection.cursor() as c:
             c.execute(sql, args)
-        cls._meta.get_field(
-            'base_finds').related_model.cached_label_bulk_update(**kwargs)
+        cls._meta.get_field("base_finds").related_model.cached_label_bulk_update(
+            **kwargs
+        )
 
     @property
     def short_label(self):
-        return settings.JOINT.join([str(item) for item in [
-            self.operation.get_reference(), self.parcel, self.label] if item])
+        return settings.JOINT.join(
+            [
+                str(item)
+                for item in [self.operation.get_reference(), self.parcel, self.label]
+                if item
+            ]
+        )
 
     @property
     def relation_label(self):
@@ -796,49 +938,66 @@ class ContextRecord(BulkUpdatedItem, DocumentItem, BaseHistorizedItem,
     def all_base_finds(self):
         BaseFind = apps.get_model("archaeological_finds", "BaseFind")
         ids = [self.id] + [
-            cr.cr_id for cr in ContextRecordTree.objects.filter(
-                cr_parent_id=self.id)]
+            cr.cr_id for cr in ContextRecordTree.objects.filter(cr_parent_id=self.id)
+        ]
         return BaseFind.objects.filter(context_record_id__in=ids)
 
     @property
     def show_url(self):
-        return reverse('show-contextrecord', args=[self.pk, ''])
+        return reverse("show-contextrecord", args=[self.pk, ""])
 
     def get_extra_actions(self, request):
         # url, base_text, icon, extra_text, extra css class, is a quick action
         actions = super(ContextRecord, self).get_extra_actions(request)
 
-        #is_locked = hasattr(self, "is_locked") and self.is_locked(request.user)
-        can_edit_cr = self.can_do(request, 'change_contextrecord')
+        # is_locked = hasattr(self, "is_locked") and self.is_locked(request.user)
+        can_edit_cr = self.can_do(request, "change_contextrecord")
         if can_edit_cr:
             actions += [
-                (reverse("contextrecord-qa-duplicate", args=[self.pk]),
-                 _("Duplicate"), "fa fa-clone", "", "", True),
+                (
+                    reverse("contextrecord-qa-duplicate", args=[self.pk]),
+                    _("Duplicate"),
+                    "fa fa-clone",
+                    "",
+                    "",
+                    True,
+                ),
             ]
         return actions
 
     @classmethod
     def get_query_owns(cls, ishtaruser):
-        return cls._construct_query_own(
-            'operation__', Operation._get_query_owns_dicts(ishtaruser)
-        ) | cls._construct_query_own(
-            'base_finds__find__basket__',
-            [{"shared_with": ishtaruser, "shared_write_with": ishtaruser}]
-        ) | cls._construct_query_own('', [
-            {'history_creator': ishtaruser.user_ptr},
-            {'operation__end_date__isnull': True}
-        ])
+        return (
+            cls._construct_query_own(
+                "operation__", Operation._get_query_owns_dicts(ishtaruser)
+            )
+            | cls._construct_query_own(
+                "base_finds__find__basket__",
+                [{"shared_with": ishtaruser, "shared_write_with": ishtaruser}],
+            )
+            | cls._construct_query_own(
+                "",
+                [
+                    {"history_creator": ishtaruser.user_ptr},
+                    {"operation__end_date__isnull": True},
+                ],
+            )
+        )
 
     @classmethod
-    def get_owns(cls, user, menu_filtr=None, limit=None,
-                 values=None, get_short_menu_class=None):
+    def get_owns(
+        cls, user, menu_filtr=None, limit=None, values=None, get_short_menu_class=None
+    ):
         replace_query = None
-        if menu_filtr and 'operation' in menu_filtr:
-            replace_query = Q(operation=menu_filtr['operation'])
+        if menu_filtr and "operation" in menu_filtr:
+            replace_query = Q(operation=menu_filtr["operation"])
         owns = super(ContextRecord, cls).get_owns(
-            user, replace_query=replace_query,
-            limit=limit, values=values,
-            get_short_menu_class=get_short_menu_class)
+            user,
+            replace_query=replace_query,
+            limit=limit,
+            values=values,
+            get_short_menu_class=get_short_menu_class,
+        )
         return cls._return_get_owns(owns, values, get_short_menu_class)
 
     def full_label(self):
@@ -847,15 +1006,22 @@ class ContextRecord(BulkUpdatedItem, DocumentItem, BaseHistorizedItem,
     def _real_label(self):
         if not self.operation.code_patriarche:
             return
-        return settings.JOINT.join((self.operation.code_patriarche,
-                                    self.label))
+        return settings.JOINT.join((self.operation.code_patriarche, self.label))
 
     def _temp_label(self):
         if self.operation.code_patriarche:
             return
-        return settings.JOINT.join([str(lbl) for lbl in [
-            self.operation.year, self.operation.operation_code, self.label]
-            if lbl])
+        return settings.JOINT.join(
+            [
+                str(lbl)
+                for lbl in [
+                    self.operation.year,
+                    self.operation.operation_code,
+                    self.label,
+                ]
+                if lbl
+            ]
+        )
 
     def _generate_cached_label(self):
         return self.full_label()
@@ -869,17 +1035,18 @@ class ContextRecord(BulkUpdatedItem, DocumentItem, BaseHistorizedItem,
     def _get_associated_cached_labels(self):
         BaseFind = apps.get_model("archaeological_finds", "BaseFind")
         Find = apps.get_model("archaeological_finds", "Find")
-        return list(Find.objects.filter(base_finds__context_record=self).all())\
-            + list(BaseFind.objects.filter(context_record=self).all())
+        return list(Find.objects.filter(base_finds__context_record=self).all()) + list(
+            BaseFind.objects.filter(context_record=self).all()
+        )
 
     def _cached_labels_bulk_update(self):
-        self.base_finds.model.cached_label_bulk_update(
-            context_record_id=self.pk)
+        self.base_finds.model.cached_label_bulk_update(context_record_id=self.pk)
         return True
 
     def _get_base_image_path(self):
-        return self.operation._get_base_image_path() + \
-               "/{}/{}".format(self.SLUG, slugify(self.label or "00"))
+        return self.operation._get_base_image_path() + "/{}/{}".format(
+            self.SLUG, slugify(self.label or "00")
+        )
 
     @property
     def archaeological_site_reference(self):
@@ -887,7 +1054,8 @@ class ContextRecord(BulkUpdatedItem, DocumentItem, BaseHistorizedItem,
             return self.archaeological_site.reference
         if self.operation.archaeological_sites.count():
             return "-".join(
-                a.reference for a in self.operation.archaeological_sites.all())
+                a.reference for a in self.operation.archaeological_sites.all()
+            )
         return ""
 
     @property
@@ -907,15 +1075,15 @@ class ContextRecord(BulkUpdatedItem, DocumentItem, BaseHistorizedItem,
         return self.operation.get_town_label()
 
     @classmethod
-    def get_periods(cls, slice='year', fltr={}):
+    def get_periods(cls, slice="year", fltr={}):
         q = cls.objects
         if fltr:
             q = q.filter(**fltr)
-        if slice == 'year':
+        if slice == "year":
             years = set()
-            for res in list(q.values('operation__start_date')):
-                if res['operation__start_date']:
-                    yr = res['operation__start_date'].year
+            for res in list(q.values("operation__start_date")):
+                if res["operation__start_date"]:
+                    yr = res["operation__start_date"].year
                     years.add(yr)
             return list(years)
         return []
@@ -929,8 +1097,10 @@ class ContextRecord(BulkUpdatedItem, DocumentItem, BaseHistorizedItem,
 
     @classmethod
     def get_operations(cls):
-        return [dct['operation__pk']
-                for dct in cls.objects.values('operation__pk').distinct()]
+        return [
+            dct["operation__pk"]
+            for dct in cls.objects.values("operation__pk").distinct()
+        ]
 
     @classmethod
     def get_by_operation(cls, operation_id):
@@ -963,7 +1133,8 @@ class ContextRecord(BulkUpdatedItem, DocumentItem, BaseHistorizedItem,
     def save(self, *args, **kwargs):
         super(ContextRecord, self).save(*args, **kwargs)
         if (not self.town and self.parcel) or (
-                self.parcel and self.parcel.town != self.town):
+            self.parcel and self.parcel.town != self.town
+        ):
             self.town = self.parcel.town
             self.skip_history_when_saving = True
             self.save()
@@ -975,40 +1146,44 @@ def context_record_post_save(sender, **kwargs):
 
 
 post_save.connect(context_record_post_save, sender=ContextRecord)
-m2m_changed.connect(document_attached_changed,
-                    sender=ContextRecord.documents.through)
+m2m_changed.connect(document_attached_changed, sender=ContextRecord.documents.through)
 
 for attr in ContextRecord.HISTORICAL_M2M:
-    m2m_changed.connect(m2m_historization_changed,
-                        sender=getattr(ContextRecord, attr).through)
+    m2m_changed.connect(
+        m2m_historization_changed, sender=getattr(ContextRecord, attr).through
+    )
 
 
 class RelationType(GeneralRelationType):
     class Meta:
         verbose_name = _("Relation type")
         verbose_name_plural = _("Relation types")
-        ordering = ('order', 'label')
+        ordering = ("order", "label")
 
 
 class RecordRelationsManager(models.Manager):
     def get_by_natural_key(self, left_record, right_record, relation_type):
-        return self.get(left_record__uuid=left_record,
-                        right_record__uuid=right_record,
-                        relation_type__txt_idx=relation_type)
+        return self.get(
+            left_record__uuid=left_record,
+            right_record__uuid=right_record,
+            relation_type__txt_idx=relation_type,
+        )
 
 
 class RecordRelations(GeneralRecordRelations, models.Model):
-    MAIN_ATTR = 'left_record'
-    left_record = models.ForeignKey(ContextRecord,
-                                    related_name='right_relations')
-    right_record = models.ForeignKey(ContextRecord,
-                                     related_name='left_relations')
+    MAIN_ATTR = "left_record"
+    left_record = models.ForeignKey(ContextRecord, related_name="right_relations")
+    right_record = models.ForeignKey(ContextRecord, related_name="left_relations")
     relation_type = models.ForeignKey(RelationType)
     objects = RecordRelationsManager()
     TABLE_COLS = [
-        "left_record__label", "left_record__unit", "left_record__parcel",
+        "left_record__label",
+        "left_record__unit",
+        "left_record__parcel",
         "relation_type",
-        "right_record__label", "right_record__unit", "right_record__parcel",
+        "right_record__label",
+        "right_record__unit",
+        "right_record__parcel",
     ]
     COL_LABELS = {
         "left_record__label": _("ID (left)"),
@@ -1021,13 +1196,11 @@ class RecordRelations(GeneralRecordRelations, models.Model):
         "right_record__unit": _("Context record type (right)"),
         "right_record__parcel": _("Parcel (right)"),
         "right_record__description": _("Description (right)"),
-        "right_record__datings__period": _("Periods (right)")
+        "right_record__datings__period": _("Periods (right)"),
     }
 
     # search parameters
-    EXTRA_REQUEST_KEYS = {
-        "left_record__operation": "left_record__operation__pk"
-    }
+    EXTRA_REQUEST_KEYS = {"left_record__operation": "left_record__operation__pk"}
 
     class Meta:
         verbose_name = _("Record relation")
@@ -1037,8 +1210,7 @@ class RecordRelations(GeneralRecordRelations, models.Model):
         ]
 
     def natural_key(self):
-        return self.left_record.uuid, self.right_record.uuid, \
-               self.relation_type.txt_idx
+        return self.left_record.uuid, self.right_record.uuid, self.relation_type.txt_idx
 
 
 post_delete.connect(post_delete_record_relation, sender=RecordRelations)
@@ -1062,34 +1234,40 @@ class RecordRelationView(models.Model):
     """
     TABLE_COLS = [
         "relation_type",
-        "right_record__label", "right_record__unit",
+        "right_record__label",
+        "right_record__unit",
         "right_record__parcel",
-        "right_record__datings__period", "right_record__description"]
+        "right_record__datings__period",
+        "right_record__description",
+    ]
     COL_LABELS = {
         "relation_type": _("Relation type"),
         "right_record__label": _("ID"),
         "right_record__unit": _("Context record type"),
         "right_record__parcel": _("Parcel"),
         "right_record__description": _("Description"),
-        "right_record__datings__period": _("Periods")
+        "right_record__datings__period": _("Periods"),
     }
 
     # search parameters
     EXTRA_REQUEST_KEYS = {
         "left_record_id": "left_record_id",
-        "right_record__unit": "right_record__unit__label"
+        "right_record__unit": "right_record__unit__label",
     }
-    left_record = models.ForeignKey(ContextRecord, related_name='+',
-                                    on_delete=models.DO_NOTHING)
-    right_record = models.ForeignKey(ContextRecord, related_name='+',
-                                     on_delete=models.DO_NOTHING)
-    relation_type = models.ForeignKey(RelationType, related_name='+',
-                                      on_delete=models.DO_NOTHING)
+    left_record = models.ForeignKey(
+        ContextRecord, related_name="+", on_delete=models.DO_NOTHING
+    )
+    right_record = models.ForeignKey(
+        ContextRecord, related_name="+", on_delete=models.DO_NOTHING
+    )
+    relation_type = models.ForeignKey(
+        RelationType, related_name="+", on_delete=models.DO_NOTHING
+    )
 
     class Meta:
         managed = False
-        db_table = 'record_relations'
-        unique_together = ('id', 'right_record')
+        db_table = "record_relations"
+        unique_together = ("id", "right_record")
         permissions = [
             ("view_recordrelation", "Can view all record relations - view"),
         ]
@@ -1099,7 +1277,7 @@ class RecordRelationView(models.Model):
         return []
 
     def __str__(self):
-        return "{} \"{}\"".format(self.relation_type, self.right_record)
+        return '{} "{}"'.format(self.relation_type, self.right_record)
 
 
 class ContextRecordTree(models.Model):
@@ -1178,13 +1356,14 @@ class ContextRecordTree(models.Model):
     cr = models.ForeignKey(
         "archaeological_context_records.ContextRecord",
         verbose_name=_("Context record"),
-        related_name="context_record_tree_parent")
+        related_name="context_record_tree_parent",
+    )
     cr_parent = models.ForeignKey(
         "archaeological_context_records.ContextRecord",
         verbose_name=_("Context record parent"),
-        related_name="context_record_tree_child")
+        related_name="context_record_tree_child",
+    )
 
     class Meta:
         managed = False
-        db_table = 'context_records_tree'
-
+        db_table = "context_records_tree"
diff --git a/archaeological_context_records/serializers.py b/archaeological_context_records/serializers.py
index a41e2bd40..2bccc63f7 100644
--- a/archaeological_context_records/serializers.py
+++ b/archaeological_context_records/serializers.py
@@ -1,16 +1,14 @@
 from django.db.models import Q
 
-from ishtar_common.serializers_utils import generic_get_results, \
-    archive_serialization
+from ishtar_common.serializers_utils import generic_get_results, archive_serialization
 from archaeological_context_records import models
 from archaeological_finds.models import Find
 
-from archaeological_finds.serializers import generate_warehouse_queryset \
-    as finds_generate_warehouse_queryset
+from archaeological_finds.serializers import (
+    generate_warehouse_queryset as finds_generate_warehouse_queryset,
+)
 
-CR_MODEL_LIST = [
-    models.Dating, models.ContextRecord, models.RecordRelations
-]
+CR_MODEL_LIST = [models.Dating, models.ContextRecord, models.RecordRelations]
 
 # TODO: associated documents
 
@@ -22,14 +20,23 @@ def generate_warehouse_queryset(ids):
 
     for container_key in ("container", "container_ref"):
         for warehouse_key in ("location", "responsible"):
-            q_c = Q(**
-                    {"{}__{}__{}__id__in".format(
-                        base_query_key, container_key, warehouse_key): ids})
-            q_r = Q(**
-                    {"left_record__{}__{}__{}__id__in".format(
-                        base_query_key, container_key, warehouse_key): ids,
-                     "right_record__{}__{}__{}__id__in".format(
-                         base_query_key, container_key, warehouse_key): ids})
+            q_c = Q(
+                **{
+                    "{}__{}__{}__id__in".format(
+                        base_query_key, container_key, warehouse_key
+                    ): ids
+                }
+            )
+            q_r = Q(
+                **{
+                    "left_record__{}__{}__{}__id__in".format(
+                        base_query_key, container_key, warehouse_key
+                    ): ids,
+                    "right_record__{}__{}__{}__id__in".format(
+                        base_query_key, container_key, warehouse_key
+                    ): ids,
+                }
+            )
         if not q_cr:
             q_cr = q_c
             q_record_relation = q_r
@@ -38,82 +45,86 @@ def generate_warehouse_queryset(ids):
             q_record_relation |= q_r
 
     result_queryset = {
-        models.ContextRecord.__name__: models.ContextRecord.objects.filter(
-            q_cr),
-        models.RecordRelations.__name__:
-            models.RecordRelations.objects.filter(q_r)
+        models.ContextRecord.__name__: models.ContextRecord.objects.filter(q_cr),
+        models.RecordRelations.__name__: models.RecordRelations.objects.filter(q_r),
     }
     return result_queryset
 
 
-def cr_serialization(archive=False, return_empty_types=False,
-                     archive_name=None, operation_queryset=None,
-                     site_queryset=None, cr_queryset=None, find_queryset=None,
-                     warehouse_queryset=None, get_queryset=False, no_geo=True,
-                     put_locks=False, lock_user=None):
+def cr_serialization(
+    archive=False,
+    return_empty_types=False,
+    archive_name=None,
+    operation_queryset=None,
+    site_queryset=None,
+    cr_queryset=None,
+    find_queryset=None,
+    warehouse_queryset=None,
+    get_queryset=False,
+    no_geo=True,
+    put_locks=False,
+    lock_user=None,
+):
     result_queryset = {}
     find_ids, cr_ids = None, None
     if operation_queryset:
         operation_ids = operation_queryset.values_list("id", flat=True)
         result_queryset = {
-            models.ContextRecord.__name__:
-                models.ContextRecord.objects.filter(
-                    operation_id__in=operation_ids),
-            models.RecordRelations.__name__:
-                models.RecordRelations.objects.filter(
-                    left_record__operation_id__in=operation_ids,
-                    right_record__operation_id__in=operation_ids,
-                ),
+            models.ContextRecord.__name__: models.ContextRecord.objects.filter(
+                operation_id__in=operation_ids
+            ),
+            models.RecordRelations.__name__: models.RecordRelations.objects.filter(
+                left_record__operation_id__in=operation_ids,
+                right_record__operation_id__in=operation_ids,
+            ),
         }
         cr_ids = list(
-            result_queryset[models.ContextRecord.__name__].values_list(
-                "id", flat=True))
+            result_queryset[models.ContextRecord.__name__].values_list("id", flat=True)
+        )
         find_ids = list(
             Find.objects.filter(
                 base_finds__context_record__operation_id__in=operation_ids
-            ).values_list("id", flat=True))
+            ).values_list("id", flat=True)
+        )
     elif site_queryset:
         site_ids = site_queryset.values_list("id", flat=True)
         result_queryset = {
-            models.ContextRecord.__name__:
-                models.ContextRecord.objects.filter(
-                    operation__archaeological_sites__id__in=site_ids),
-            models.RecordRelations.__name__:
-                models.RecordRelations.objects.filter(
-                    left_record__operation__archaeological_sites__id__in=site_ids,
-                    right_record__operation__archaeological_sites__id__in=site_ids,
-                )
+            models.ContextRecord.__name__: models.ContextRecord.objects.filter(
+                operation__archaeological_sites__id__in=site_ids
+            ),
+            models.RecordRelations.__name__: models.RecordRelations.objects.filter(
+                left_record__operation__archaeological_sites__id__in=site_ids,
+                right_record__operation__archaeological_sites__id__in=site_ids,
+            ),
         }
         f_q = {
             "base_finds__context_record__operation__archaeological_sites__id__in": site_ids
         }
-        find_ids = list(
-            Find.objects.filter(**f_q).values_list("id", flat=True))
+        find_ids = list(Find.objects.filter(**f_q).values_list("id", flat=True))
     elif cr_queryset:
         cr_ids = cr_queryset.values_list("id", flat=True)
         result_queryset = {
             models.ContextRecord.__name__: cr_queryset,
-            models.RecordRelations.__name__:
-                models.RecordRelations.objects.filter(
-                    left_record_id__in=cr_ids,
-                    right_record_id__in=cr_ids,
-                )
+            models.RecordRelations.__name__: models.RecordRelations.objects.filter(
+                left_record_id__in=cr_ids,
+                right_record_id__in=cr_ids,
+            ),
         }
         find_ids = list(
-            Find.objects.filter(
-                base_finds__context_record__in=cr_ids).values_list(
-                "id", flat=True))
+            Find.objects.filter(base_finds__context_record__in=cr_ids).values_list(
+                "id", flat=True
+            )
+        )
     elif find_queryset:
         find_ids = find_queryset.values_list("id", flat=True)
         result_queryset = {
             models.ContextRecord.__name__: models.ContextRecord.objects.filter(
                 base_finds__find__id__in=find_ids,
             ),
-            models.RecordRelations.__name__:
-                models.RecordRelations.objects.filter(
-                    left_record__base_finds__find__id__in=find_ids,
-                    right_record__base_finds__find__id__in=find_ids,
-                )
+            models.RecordRelations.__name__: models.RecordRelations.objects.filter(
+                left_record__base_finds__find__id__in=find_ids,
+                right_record__base_finds__find__id__in=find_ids,
+            ),
         }
     elif warehouse_queryset:
         warehouse_ids = warehouse_queryset.values_list("id", flat=True)
@@ -123,18 +134,18 @@ def cr_serialization(archive=False, return_empty_types=False,
 
     if result_queryset:
         cr_ids = list(
-            result_queryset[models.ContextRecord.__name__].values_list(
-                "id", flat=True))
+            result_queryset[models.ContextRecord.__name__].values_list("id", flat=True)
+        )
         result_queryset[models.Dating.__name__] = models.Dating.objects.filter(
-            Q(context_records__id__in=cr_ids) |
-            Q(find__id__in=list(find_ids))
+            Q(context_records__id__in=cr_ids) | Q(find__id__in=list(find_ids))
         )
 
     if get_queryset:
         return result_queryset
 
-    result = generic_get_results(CR_MODEL_LIST, "context_records",
-                                 result_queryset=result_queryset, no_geo=no_geo)
+    result = generic_get_results(
+        CR_MODEL_LIST, "context_records", result_queryset=result_queryset, no_geo=no_geo
+    )
     if put_locks:
         for model in CR_MODEL_LIST:
             if not hasattr(model, "locked"):
@@ -145,7 +156,10 @@ def cr_serialization(archive=False, return_empty_types=False,
             q.update(locked=True, lock_user=lock_user)
 
     full_archive = archive_serialization(
-        result, archive_dir="context_records", archive=archive,
-        return_empty_types=return_empty_types, archive_name=archive_name,
+        result,
+        archive_dir="context_records",
+        archive=archive,
+        return_empty_types=return_empty_types,
+        archive_name=archive_name,
     )
     return full_archive
diff --git a/archaeological_context_records/tests.py b/archaeological_context_records/tests.py
index fef557cf3..64950bd91 100644
--- a/archaeological_context_records/tests.py
+++ b/archaeological_context_records/tests.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 # Copyright (C) 2015-2018 Étienne Loks  <etienne.loks_AT_peacefrogsDOTnet>
 
@@ -29,21 +29,38 @@ from django.core.urlresolvers import reverse
 from django.test.client import Client
 from django.utils.translation import pgettext_lazy
 
-from ishtar_common.models import IshtarSiteProfile, ImporterModel, \
-    UserProfile, ProfileType, Town, Area, get_current_profile
-
-from archaeological_operations.tests import OperationInitTest, \
-    ImportTest
+from ishtar_common.models import (
+    IshtarSiteProfile,
+    ImporterModel,
+    UserProfile,
+    ProfileType,
+    Town,
+    Area,
+    get_current_profile,
+)
+
+from archaeological_operations.tests import OperationInitTest, ImportTest
 from archaeological_operations import models as models_ope
 from archaeological_context_records import models
 
 from ishtar_common.utils import generate_relation_graph
 
-from ishtar_common.tests import WizardTest, WizardTestFormData as FormData, \
-    create_superuser, create_user, TestCase, AutocompleteTestBase, AcItem, \
-    CONTEXT_RECORD_FIXTURES, CONTEXT_RECORD_TOWNS_FIXTURES, \
-    OPERATION_TOWNS_FIXTURES, GenericSerializationTest, COMMON_FIXTURES, \
-    WAREHOUSE_FIXTURES, SearchText
+from ishtar_common.tests import (
+    WizardTest,
+    WizardTestFormData as FormData,
+    create_superuser,
+    create_user,
+    TestCase,
+    AutocompleteTestBase,
+    AcItem,
+    CONTEXT_RECORD_FIXTURES,
+    CONTEXT_RECORD_TOWNS_FIXTURES,
+    OPERATION_TOWNS_FIXTURES,
+    GenericSerializationTest,
+    COMMON_FIXTURES,
+    WAREHOUSE_FIXTURES,
+    SearchText,
+)
 
 from archaeological_operations.models import Operation
 from archaeological_operations.serializers import operation_serialization
@@ -67,14 +84,15 @@ class ImportContextRecordTest(ImportTest, TestCase):
         current_nb = models.ContextRecord.objects.count()
         self.assertEqual(current_nb, old_nb + 4)
         self.assertEqual(
-            models.ContextRecord.objects.filter(
-                unit__txt_idx='not_in_context').count(), 3)
+            models.ContextRecord.objects.filter(unit__txt_idx="not_in_context").count(),
+            3,
+        )
         self.assertEqual(
-            models.ContextRecord.objects.filter(
-                unit__txt_idx='negative').count(), 1)
+            models.ContextRecord.objects.filter(unit__txt_idx="negative").count(), 1
+        )
 
     def test_model_limitation(self):
-        locale.setlocale(locale.LC_ALL, 'fr_FR.UTF-8')
+        locale.setlocale(locale.LC_ALL, "fr_FR.UTF-8")
         old_nb = models.ContextRecord.objects.count()
         mcc, form = self.init_context_record_import()
         mcc.created_models.clear()
@@ -94,9 +112,9 @@ class ImportContextRecordTest(ImportTest, TestCase):
             cr.delete()
         mcc, form = self.init_context_record_import()
         mcc.created_models.clear()
-        mcc.created_models.add(ImporterModel.objects.get(
-            klass='ishtar_common.models.Organization'
-        ))
+        mcc.created_models.add(
+            ImporterModel.objects.get(klass="ishtar_common.models.Organization")
+        )
         impt = form.save(self.ishtar_user)
         impt.initialize()
         self.init_cr_targetkey(impt)
@@ -105,8 +123,8 @@ class ImportContextRecordTest(ImportTest, TestCase):
         impt.importation()
         self.assertEqual(len(impt.errors), 5)
         self.assertTrue(
-            "doesn't exist in the database." in impt.errors[0]['error'] or
-            "n'existe pas dans la base" in impt.errors[0]['error']
+            "doesn't exist in the database." in impt.errors[0]["error"]
+            or "n'existe pas dans la base" in impt.errors[0]["error"]
         )
 
         # retry with only Dating (no context record)
@@ -115,8 +133,9 @@ class ImportContextRecordTest(ImportTest, TestCase):
         mcc, form = self.init_context_record_import()
         mcc.created_models.clear()
         dat_model, c = ImporterModel.objects.get_or_create(
-            klass='archaeological_context_records.models.Dating',
-            defaults={"name": 'Dating'})
+            klass="archaeological_context_records.models.Dating",
+            defaults={"name": "Dating"},
+        )
         mcc.created_models.add(dat_model)
         impt = form.save(self.ishtar_user)
         impt.initialize()
@@ -131,9 +150,11 @@ class ImportContextRecordTest(ImportTest, TestCase):
             cr.delete()
         mcc, form = self.init_context_record_import()
         mcc.created_models.clear()
-        mcc.created_models.add(ImporterModel.objects.get(
-            klass='archaeological_context_records.models.ContextRecord'
-        ))
+        mcc.created_models.add(
+            ImporterModel.objects.get(
+                klass="archaeological_context_records.models.ContextRecord"
+            )
+        )
         mcc.created_models.add(dat_model)
         impt = form.save(self.ishtar_user)
         impt.initialize()
@@ -141,7 +162,7 @@ class ImportContextRecordTest(ImportTest, TestCase):
         impt.importation()
         current_nb = models.ContextRecord.objects.count()
         self.assertEqual(current_nb, 4)
-        '''
+        """
 
         # add a context record model
         for cr in models.ContextRecord.objects.all():
@@ -157,7 +178,7 @@ class ImportContextRecordTest(ImportTest, TestCase):
         impt.importation()
         current_nb = models.ContextRecord.objects.count()
         self.assertEqual(current_nb, 4)
-        '''
+        """
 
 
 class ContextRecordInit(OperationInitTest):
@@ -165,31 +186,31 @@ class ContextRecordInit(OperationInitTest):
         if not data:
             data = {}
 
-        if not getattr(self, 'context_records', None):
+        if not getattr(self, "context_records", None):
             self.context_records = []
 
-        default = {'label': "Context record"}
-        if force or not data.get('operation') \
-                or not models.Operation.objects.filter(
-                    pk=data['operation'].pk).count():
-            data['operation'] = self.get_default_operation(force=force,
-                                                           user=user)
-        if not data.get('parcel') or not data['parcel'].pk \
-            or not models.Parcel.objects.filter(
-                pk=data['parcel'].pk).count():
-            data['parcel'] = self.get_default_parcel(force=force)
+        default = {"label": "Context record"}
+        if (
+            force
+            or not data.get("operation")
+            or not models.Operation.objects.filter(pk=data["operation"].pk).count()
+        ):
+            data["operation"] = self.get_default_operation(force=force, user=user)
+        if (
+            not data.get("parcel")
+            or not data["parcel"].pk
+            or not models.Parcel.objects.filter(pk=data["parcel"].pk).count()
+        ):
+            data["parcel"] = self.get_default_parcel(force=force)
         if user:
-            data['history_modifier'] = user
-        elif not data.get('history_modifier'):
-            data['history_modifier'] = self.get_default_user()
+            data["history_modifier"] = user
+        elif not data.get("history_modifier"):
+            data["history_modifier"] = self.get_default_user()
 
         default.update(data)
-        data['operation'] = models.Operation.objects.get(
-            pk=data['operation'].pk)
-        data['parcel'] = models.Parcel.objects.get(
-            pk=data['parcel'].pk)
-        self.context_records.append(models.ContextRecord.objects.create(
-            **default))
+        data["operation"] = models.Operation.objects.get(pk=data["operation"].pk)
+        data["parcel"] = models.Parcel.objects.get(pk=data["parcel"].pk)
+        self.context_records.append(models.ContextRecord.objects.create(**default))
         return self.context_records
 
     def get_default_context_record(self, force=False, user=None):
@@ -198,7 +219,7 @@ class ContextRecordInit(OperationInitTest):
         return self.create_context_record(force=force, user=user)[0]
 
     def tearDown(self):
-        if hasattr(self, 'context_records'):
+        if hasattr(self, "context_records"):
             for cr in self.context_records:
                 try:
                     cr.delete()
@@ -214,84 +235,80 @@ class SerializationTest(GenericSerializationTest, ContextRecordInit, 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]
         dating = models.Dating.objects.create(
             period=models.Period.objects.all()[0],
         )
         cr.datings.add(dating)
         rlt = models.RelationType.objects.create(
-            label="Test",
-            txt_idx="test",
-            symmetrical=False
+            label="Test", txt_idx="test", symmetrical=False
         )
         models.RecordRelations.objects.create(
-            left_record=cr,
-            right_record=cr2,
-            relation_type=rlt
+            left_record=cr, right_record=cr2, relation_type=rlt
         )
 
     def test_serialization(self):
         res = self.generic_serialization_test(serializers.cr_serialization)
         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 = Operation.objects.filter(uuid=self.operations[0].uuid)
         res = self.generic_serialization_test(
-            serializers.cr_serialization, no_test=True,
-            kwargs={"operation_queryset": result_queryset}
+            serializers.cr_serialization,
+            no_test=True,
+            kwargs={"operation_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)
 
         result_queryset = models.ContextRecord.objects.filter(
-            uuid=self.context_records[0].uuid)
+            uuid=self.context_records[0].uuid
+        )
         res = self.generic_serialization_test(
-            serializers.cr_serialization, no_test=True,
-            kwargs={"cr_queryset": result_queryset}
+            serializers.cr_serialization,
+            no_test=True,
+            kwargs={"cr_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_ope_serialization_with_cr_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.ContextRecord.objects.filter(
-            uuid=self.context_records[0].uuid)
+            uuid=self.context_records[0].uuid
+        )
         res = self.generic_serialization_test(
-            operation_serialization, no_test=True,
-            kwargs={"cr_queryset": result_queryset}
+            operation_serialization,
+            no_test=True,
+            kwargs={"cr_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_restore(self):
         current_number, zip_filename = self.generic_restore_test_genzip(
-            serializers.CR_MODEL_LIST,
-            serializers.cr_serialization)
-        self.generic_restore_test(zip_filename, current_number,
-                                  serializers.CR_MODEL_LIST)
+            serializers.CR_MODEL_LIST, serializers.cr_serialization
+        )
+        self.generic_restore_test(
+            zip_filename, current_number, serializers.CR_MODEL_LIST
+        )
 
 
 class ExportTest(ContextRecordInit, TestCase):
@@ -306,22 +323,22 @@ class ExportTest(ContextRecordInit, TestCase):
         ope.save()
         cr = self.create_context_record(data={"label": "CR 1"})[0]
         c = Client()
-        url = reverse('get-by-importer',
-                      kwargs={'slug': 'ishtar-context-record',
-                              'type': 'csv'})
+        url = reverse(
+            "get-by-importer", kwargs={"slug": "ishtar-context-record", "type": "csv"}
+        )
         response = c.get(url)
         # no result when no authentication
         self.assertTrue(not response.content)
         c.login(username=self.username, password=self.password)
         response = c.get(url)
-        ENCODING = settings.ENCODING or 'utf-8'
+        ENCODING = settings.ENCODING or "utf-8"
         rows = list(csv.reader(StringIO(response.content.decode(ENCODING))))
         # one header + one context record
         self.assertEqual(len(rows), 2)
         row_cr = rows[1]
-        self.assertEqual(row_cr[0], '45000')
-        self.assertEqual(row_cr[1], '12345')
-        self.assertEqual(row_cr[2], 'A1')
+        self.assertEqual(row_cr[0], "45000")
+        self.assertEqual(row_cr[1], "12345")
+        self.assertEqual(row_cr[2], "A1")
 
 
 class ContextRecordTest(ContextRecordInit, TestCase):
@@ -335,17 +352,17 @@ class ContextRecordTest(ContextRecordInit, TestCase):
 
         cr_1 = self.context_records[0]
         cr_2 = self.context_records[1]
-        sym_rel_type = models.RelationType.objects.filter(
-            symmetrical=True).all()[0]
+        sym_rel_type = models.RelationType.objects.filter(symmetrical=True).all()[0]
         self.cr_rel_type = sym_rel_type
         models.RecordRelations.objects.create(
-            left_record=cr_1, right_record=cr_2, relation_type=sym_rel_type)
+            left_record=cr_1, right_record=cr_2, relation_type=sym_rel_type
+        )
 
     def test_external_id(self):
         cr = self.context_records[0]
         self.assertEqual(
-            cr.external_id,
-            "{}-{}".format(cr.parcel.external_id, cr.label))
+            cr.external_id, "{}-{}".format(cr.parcel.external_id, cr.label)
+        )
 
     def test_lost_parcel_dont_delete_context_record(self):
         cr = self.create_context_record(force=True)[0]
@@ -353,12 +370,10 @@ class ContextRecordTest(ContextRecordInit, TestCase):
         parcel.operation = None
         parcel.save()
         # associated context record is not removed
-        self.assertEqual(
-            models.ContextRecord.objects.filter(pk=cr.pk).count(), 1)
+        self.assertEqual(models.ContextRecord.objects.filter(pk=cr.pk).count(), 1)
         # associated operation is restored
         self.assertEqual(
-            models.Parcel.objects.get(pk=parcel.pk).operation,
-            cr.operation
+            models.Parcel.objects.get(pk=parcel.pk).operation, cr.operation
         )
 
     def test_search_vector_update(self):
@@ -369,7 +384,7 @@ class ContextRecordTest(ContextRecordInit, TestCase):
         cr.save()
         cr = models.ContextRecord.objects.get(pk=cr.pk)
         self.assertIsNotNone(cr.search_vector)
-        for key in ('label', 'heeer'):
+        for key in ("label", "heeer"):
             self.assertIn(key, cr.search_vector)
         cr.operation.code_patriarche = "PATRIARCHE"
         cr.operation.save()
@@ -377,16 +392,15 @@ class ContextRecordTest(ContextRecordInit, TestCase):
 
         profile = get_current_profile()
         self.assertIsNotNone(cr.cached_label)
-        self.assertIn(profile.operation_prefix.lower() + "patriarch",
-                      cr.search_vector)
+        self.assertIn(profile.operation_prefix.lower() + "patriarch", cr.search_vector)
 
     def test_upstream_cache_update(self):
         cr = self.create_context_record()[0]
         cr_pk = cr.pk
         self.assertIsNotNone(cr.cached_label)
         # OA1 | A | 1 | CR 1
-        ope_id, parcel_sec, parcel_nb, cr_label = cr.cached_label.split(' | ')
-        self.assertEqual(ope_id, 'OA1')
+        ope_id, parcel_sec, parcel_nb, cr_label = cr.cached_label.split(" | ")
+        self.assertEqual(ope_id, "OA1")
         self.assertEqual(parcel_sec, cr.parcel.section)
         self.assertEqual(parcel_nb, cr.parcel.parcel_number)
         self.assertEqual(cr_label, cr.label)
@@ -396,7 +410,7 @@ class ContextRecordTest(ContextRecordInit, TestCase):
         cr.save()
         cr = models.ContextRecord.objects.get(pk=cr_pk)
         self.assertIsNotNone(cr.cached_label)
-        ope_id, parcel_sec, parcel_nb, cr_label = cr.cached_label.split(' | ')
+        ope_id, parcel_sec, parcel_nb, cr_label = cr.cached_label.split(" | ")
         self.assertEqual(cr_label, new_lbl)
 
         new_sec, new_nb = "B", "42"
@@ -406,7 +420,7 @@ class ContextRecordTest(ContextRecordInit, TestCase):
         parcel.save()
         cr = models.ContextRecord.objects.get(pk=cr_pk)
         self.assertIsNotNone(cr.cached_label)
-        ope_id, parcel_sec, parcel_nb, cr_label = cr.cached_label.split(' | ')
+        ope_id, parcel_sec, parcel_nb, cr_label = cr.cached_label.split(" | ")
         self.assertEqual(parcel_sec, new_sec)
         self.assertEqual(parcel_nb, new_nb)
 
@@ -414,8 +428,8 @@ class ContextRecordTest(ContextRecordInit, TestCase):
         cr.operation.save()
         cr = models.ContextRecord.objects.get(pk=cr_pk)
         self.assertIsNotNone(cr.cached_label)
-        ope_id, parcel_sec, parcel_nb, cr_label = cr.cached_label.split(' | ')
-        self.assertEqual(ope_id, 'OA1')
+        ope_id, parcel_sec, parcel_nb, cr_label = cr.cached_label.split(" | ")
+        self.assertEqual(ope_id, "OA1")
 
     def test_downstream_cache_update(self):
         cr = self.create_context_record()[0]
@@ -423,19 +437,19 @@ class ContextRecordTest(ContextRecordInit, TestCase):
         from archaeological_finds.models import Find, BaseFind, MaterialType
 
         data = {
-            'label': "Find me a reason",
-            'context_record': cr,
-            'history_modifier': self.get_default_user()
+            "label": "Find me a reason",
+            "context_record": cr,
+            "history_modifier": self.get_default_user(),
         }
         bf = BaseFind.objects.create(**data)
         find = Find.objects.create(
-            history_modifier=self.get_default_user(),
-            label='Find me too'
+            history_modifier=self.get_default_user(), label="Find me too"
         )
         find.base_finds.add(bf)
 
         mat = MaterialType.objects.create(
-            label='Adamentium', txt_idx='admentium', code='ADA')
+            label="Adamentium", txt_idx="admentium", code="ADA"
+        )
         find.material_types.add(mat)
 
         class TestObj(object):
@@ -443,7 +457,7 @@ class ContextRecordTest(ContextRecordInit, TestCase):
                 self.find_reached = []
 
             def reached(self, sender, **kwargs):
-                instance = kwargs.get('instance')
+                instance = kwargs.get("instance")
                 if sender in (Find, BaseFind):
                     self.find_reached.append(instance)
 
@@ -464,21 +478,23 @@ class ContextRecordTest(ContextRecordInit, TestCase):
     def test_show(self):
         obj = self.context_records[0]
         c = Client()
-        response = c.get(reverse('show-contextrecord', kwargs={'pk': obj.pk}))
+        response = c.get(reverse("show-contextrecord", kwargs={"pk": obj.pk}))
         self.assertEqual(response.status_code, 200)
         # empty content when not allowed
         self.assertEqual(response.content, b"")
 
         c.login(username=self.username, password=self.password)
-        response = c.get(reverse('show-contextrecord', kwargs={'pk': obj.pk}))
+        response = c.get(reverse("show-contextrecord", kwargs={"pk": obj.pk}))
         self.assertEqual(response.status_code, 200)
         self.assertIn(b'class="card sheet"', response.content)
 
     def test_redundant_dating_clean(self):
         obj = self.context_records[0]
-        values = {'period': models.Period.objects.all()[0]}
-        values_2 = {'period': models.Period.objects.all()[0],
-                    'quality': models.DatingQuality.objects.all()[0]}
+        values = {"period": models.Period.objects.all()[0]}
+        values_2 = {
+            "period": models.Period.objects.all()[0],
+            "quality": models.DatingQuality.objects.all()[0],
+        }
 
         obj.datings.add(models.Dating.objects.create(**values))
         obj.datings.add(models.Dating.objects.create(**values))
@@ -490,10 +506,11 @@ class ContextRecordTest(ContextRecordInit, TestCase):
 
     def test_custom_index(self):
         profile, created = IshtarSiteProfile.objects.get_or_create(
-            slug='default', active=True)
+            slug="default", active=True
+        )
 
         # key: operation
-        profile.contextrecord_custom_index = 'operation_id'
+        profile.contextrecord_custom_index = "operation_id"
         profile.save()
         cr1 = self.context_records[0]
         cr1 = models.ContextRecord.objects.get(pk=cr1.pk)
@@ -507,17 +524,16 @@ class ContextRecordTest(ContextRecordInit, TestCase):
         cr2 = models.ContextRecord.objects.get(pk=cr2.pk)
         self.assertEqual(cr2.custom_index, 2)
         ope = self.create_operation()[-1]
-        cr3 = self.create_context_record(
-            data={"operation": ope})[-1]
+        cr3 = self.create_context_record(data={"operation": ope})[-1]
         cr3 = models.ContextRecord.objects.get(pk=cr3.pk)
         self.assertEqual(cr3.custom_index, 1)
 
         # key: operation, unit
-        profile.contextrecord_custom_index = 'unit_id;operation_id'
+        profile.contextrecord_custom_index = "unit_id;operation_id"
         profile.save()
 
-        su = models.Unit.objects.get(txt_idx='stratigraphic-unit')
-        dest = models.Unit.objects.get(txt_idx='sector')
+        su = models.Unit.objects.get(txt_idx="stratigraphic-unit")
+        dest = models.Unit.objects.get(txt_idx="sector")
         cr1.unit, cr2.unit = su, dest
         cr1.save()
         cr2.save()
@@ -547,7 +563,7 @@ class ContextRecordTest(ContextRecordInit, TestCase):
 
 class ContextRecordSearchTest(ContextRecordInit, TestCase, SearchText):
     fixtures = CONTEXT_RECORD_TOWNS_FIXTURES
-    SEARCH_URL = 'get-contextrecord'
+    SEARCH_URL = "get-contextrecord"
 
     def setUp(self):
         IshtarSiteProfile.objects.create()
@@ -557,29 +573,30 @@ class ContextRecordSearchTest(ContextRecordInit, TestCase, SearchText):
 
         cr_1 = self.context_records[0]
         cr_2 = self.context_records[1]
-        sym_rel_type = models.RelationType.objects.filter(
-            symmetrical=True).all()[0]
+        sym_rel_type = models.RelationType.objects.filter(symmetrical=True).all()[0]
         self.cr_rel_type = sym_rel_type
         models.RecordRelations.objects.create(
-            left_record=cr_1, right_record=cr_2, relation_type=sym_rel_type)
+            left_record=cr_1, right_record=cr_2, relation_type=sym_rel_type
+        )
 
     def test_town_search(self):
         c = Client()
         c.login(username=self.username, password=self.password)
 
-        data = {'numero_insee': '98989', 'name': 'base_town'}
+        data = {"numero_insee": "98989", "name": "base_town"}
         base_town = self.create_towns(datas=data)[-1]
 
-        parcel = self.create_parcel(data={'town': base_town,
-                                    'section': 'A', 'parcel_number': '1'})[-1]
+        parcel = self.create_parcel(
+            data={"town": base_town, "section": "A", "parcel_number": "1"}
+        )[-1]
         self.context_records[0].parcel = parcel
         self.context_records[0].save()
 
-        data = {'numero_insee': '56789', 'name': 'parent_town'}
+        data = {"numero_insee": "56789", "name": "parent_town"}
         parent_town = self.create_towns(datas=data)[-1]
         parent_town.children.add(base_town)
 
-        data = {'numero_insee': '01234', 'name': 'child_town'}
+        data = {"numero_insee": "01234", "name": "child_town"}
         child_town = self.create_towns(datas=data)[-1]
         base_town.children.add(child_town)
 
@@ -587,57 +604,50 @@ class ContextRecordSearchTest(ContextRecordInit, TestCase, SearchText):
 
         # simple search
         search = {town_key: base_town.cached_label}
-        response = c.get(reverse('get-contextrecord'), search)
+        response = c.get(reverse("get-contextrecord"), 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)
 
         # parent search
         search = {town_key: parent_town.cached_label}
-        response = c.get(reverse('get-contextrecord'), search)
+        response = c.get(reverse("get-contextrecord"), 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)
 
         # child search
         search = {town_key: child_town.cached_label}
-        response = c.get(reverse('get-contextrecord'), search)
+        response = c.get(reverse("get-contextrecord"), 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)
 
     def test_search_export(self):
         c = Client()
-        response = c.get(reverse('get-contextrecord'))
+        response = c.get(reverse("get-contextrecord"))
         # no result when no authentification
         self.assertTrue(not json.loads(response.content.decode()))
         c.login(username=self.username, password=self.password)
-        response = c.get(reverse('get-contextrecord'))
-        self.assertEqual(
-            json.loads(response.content.decode())['recordsTotal'], 2)
+        response = c.get(reverse("get-contextrecord"))
+        self.assertEqual(json.loads(response.content.decode())["recordsTotal"], 2)
         # test search label
-        response = c.get(reverse('get-contextrecord'), {'label': 'cr 1'})
-        self.assertEqual(
-            json.loads(response.content.decode())['recordsTotal'], 1)
+        response = c.get(reverse("get-contextrecord"), {"label": "cr 1"})
+        self.assertEqual(json.loads(response.content.decode())["recordsTotal"], 1)
         # test search between relations
-        rel_rec_key = pgettext_lazy("key for text search",
-                                    "record-relation-type")
+        rel_rec_key = pgettext_lazy("key for text search", "record-relation-type")
         response = c.get(
-            reverse('get-contextrecord'),
-            {'search_vector': 'label="cr 1" {}="{}"'.format(
-                rel_rec_key, self.cr_rel_type.label)
-            }
+            reverse("get-contextrecord"),
+            {
+                "search_vector": 'label="cr 1" {}="{}"'.format(
+                    rel_rec_key, self.cr_rel_type.label
+                )
+            },
         )
-        self.assertEqual(
-            json.loads(response.content.decode())['recordsTotal'], 2)
+        self.assertEqual(json.loads(response.content.decode())["recordsTotal"], 2)
         # test search vector
-        response = c.get(reverse('get-contextrecord'), {'search_vector': 'CR'})
-        self.assertEqual(json.loads(response.content.decode())['recordsTotal'],
-                         2)
+        response = c.get(reverse("get-contextrecord"), {"search_vector": "CR"})
+        self.assertEqual(json.loads(response.content.decode())["recordsTotal"], 2)
         # the 2 context records have the same operation
-        response = c.get(reverse('get-contextrecord'), {'search_vector': 'oa1'})
-        self.assertEqual(json.loads(response.content.decode())['recordsTotal'],
-                         2)
+        response = c.get(reverse("get-contextrecord"), {"search_vector": "oa1"})
+        self.assertEqual(json.loads(response.content.decode())["recordsTotal"], 2)
         # test search between related operations
         first_ope = self.operations[0]
         first_ope.year = 2010
@@ -652,72 +662,71 @@ class ContextRecordSearchTest(ContextRecordInit, TestCase, SearchText):
         cr_2.operation = other_ope
         cr_2.save()
         rel_ope = models_ope.RelationType.objects.create(
-            symmetrical=True, label='Linked', txt_idx='link')
+            symmetrical=True, label="Linked", txt_idx="link"
+        )
         models_ope.RecordRelations.objects.create(
-            left_record=other_ope,
-            right_record=first_ope,
-            relation_type=rel_ope)
-        rel_key = pgettext_lazy("key for text search",
-                                "operation-relation-type")
-        response = c.get(reverse('get-contextrecord'),
-                         {'operation__year': 2010,
-                          rel_key: rel_ope.label})
-        self.assertEqual(json.loads(response.content.decode())['recordsTotal'],
-                         2)
+            left_record=other_ope, right_record=first_ope, relation_type=rel_ope
+        )
+        rel_key = pgettext_lazy("key for text search", "operation-relation-type")
+        response = c.get(
+            reverse("get-contextrecord"),
+            {"operation__year": 2010, rel_key: rel_ope.label},
+        )
+        self.assertEqual(json.loads(response.content.decode())["recordsTotal"], 2)
         # export
-        response = c.get(reverse('get-contextrecord-full',
-                                 kwargs={'type': 'csv'}),
-                         {'submited': '1',
-                          'operation__year': 2010, rel_key: rel_ope.label})
-        ENCODING = settings.ENCODING or 'utf-8'
+        response = c.get(
+            reverse("get-contextrecord-full", kwargs={"type": "csv"}),
+            {"submited": "1", "operation__year": 2010, rel_key: rel_ope.label},
+        )
+        ENCODING = settings.ENCODING or "utf-8"
         content = response.content.decode(ENCODING)
         # 2 lines + header
-        lines = [line for line in content.split('\n') if line]
+        lines = [line for line in content.split("\n") if line]
         self.assertEqual(len(lines), 3)
 
     def test_unit_hierarchic_search(self):
         cr = self.context_records[0]
         c = Client()
 
-        su = models.Unit.objects.get(txt_idx='stratigraphic-unit')
-        neg = models.Unit.objects.get(txt_idx='negative')
-        dest = models.Unit.objects.get(txt_idx='sector')
+        su = models.Unit.objects.get(txt_idx="stratigraphic-unit")
+        neg = models.Unit.objects.get(txt_idx="negative")
+        dest = models.Unit.objects.get(txt_idx="sector")
         dest.parent = su
         dest.save()
-        cr.unit = (neg)
+        cr.unit = neg
         cr.save()
-        search = {'unit': neg.pk}
+        search = {"unit": neg.pk}
 
         # no result when no authentication
-        response = c.get(reverse('get-contextrecord'), search)
+        response = c.get(reverse("get-contextrecord"), search)
         self.assertEqual(response.status_code, 200)
         content = response.content.decode()
         self.assertTrue(not json.loads(content))
 
         # one result for exact search
         c.login(username=self.username, password=self.password)
-        response = c.get(reverse('get-contextrecord'), search)
+        response = c.get(reverse("get-contextrecord"), search)
         self.assertEqual(response.status_code, 200)
         res = json.loads(response.content.decode())
-        self.assertEqual(res['recordsTotal'], 1)
+        self.assertEqual(res["recordsTotal"], 1)
         self.assertEqual(res["rows"][0]["unit__label"], str(neg))
 
         # no result for the brother
-        search = {'unit': dest.pk}
-        response = c.get(reverse('get-contextrecord'), search)
+        search = {"unit": dest.pk}
+        response = c.get(reverse("get-contextrecord"), 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 = {'unit': su.pk}
-        response = c.get(reverse('get-contextrecord'), search)
+        search = {"unit": su.pk}
+        response = c.get(reverse("get-contextrecord"), 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", 'unit-type'))
+        material_key = str(pgettext_lazy("key for text search", "unit-type"))
         result = [
             ('{}="{}"'.format(material_key, str(neg)), 1),
             ('{}="{}"'.format(material_key, str(dest)), 0),
@@ -729,45 +738,43 @@ class ContextRecordSearchTest(ContextRecordInit, TestCase, SearchText):
         cr = self.context_records[0]
         c = Client()
 
-        neo = models.Period.objects.get(txt_idx='neolithic')
-        final_neo = models.Period.objects.get(txt_idx='final-neolithic')
-        recent_neo = models.Period.objects.get(txt_idx='recent-neolithic')
-        dating = models.Dating.objects.create(
-            period=final_neo
-        )
+        neo = models.Period.objects.get(txt_idx="neolithic")
+        final_neo = models.Period.objects.get(txt_idx="final-neolithic")
+        recent_neo = models.Period.objects.get(txt_idx="recent-neolithic")
+        dating = models.Dating.objects.create(period=final_neo)
         cr.datings.add(dating)
 
-        search = {'datings__period': final_neo.pk}
+        search = {"datings__period": final_neo.pk}
 
         # no result when no authentication
-        response = c.get(reverse('get-contextrecord'), search)
+        response = c.get(reverse("get-contextrecord"), search)
         self.assertEqual(response.status_code, 200)
         content = response.content.decode()
         self.assertTrue(not json.loads(content))
 
         # one result for exact search
         c.login(username=self.username, password=self.password)
-        response = c.get(reverse('get-contextrecord'), search)
+        response = c.get(reverse("get-contextrecord"), search)
         self.assertEqual(response.status_code, 200)
         res = json.loads(response.content.decode())
-        self.assertTrue(res['recordsTotal'] == 1)
+        self.assertTrue(res["recordsTotal"] == 1)
 
         # no result for the brother
-        search = {'datings__period': recent_neo.pk}
-        response = c.get(reverse('get-contextrecord'), search)
+        search = {"datings__period": recent_neo.pk}
+        response = c.get(reverse("get-contextrecord"), 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 = {'datings__period': neo.pk}
-        response = c.get(reverse('get-contextrecord'), search)
+        search = {"datings__period": neo.pk}
+        response = c.get(reverse("get-contextrecord"), 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
-        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),
@@ -783,21 +790,23 @@ class ContextRecordPermissionTest(ContextRecordInit, TestCase):
         IshtarSiteProfile.objects.create()
         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='view_own_contextrecord'))
-        self.alt_user.user_permissions.add(Permission.objects.get(
-            codename='change_own_contextrecord'))
+        self.alt_user.user_permissions.add(
+            Permission.objects.get(codename="view_own_contextrecord")
+        )
+        self.alt_user.user_permissions.add(
+            Permission.objects.get(codename="change_own_contextrecord")
+        )
         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)
@@ -807,70 +816,66 @@ class ContextRecordPermissionTest(ContextRecordInit, TestCase):
         self.operations += self.create_operation(self.alt_user, self.orgas[0])
         self.operations[1].towns.add(town)
 
-        self.create_context_record(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.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]}
+        )
         self.cr_1 = self.context_records[0]
         self.cr_2 = self.context_records[1]
 
     def test_own_search(self):
         # no result when no authentification
         c = Client()
-        response = c.get(reverse('get-contextrecord'))
+        response = c.get(reverse("get-contextrecord"))
         self.assertTrue(not json.loads(response.content.decode()))
 
         # possession
         c = Client()
         c.login(username=self.alt_username, password=self.alt_password)
-        response = c.get(reverse('get-contextrecord'))
+        response = c.get(reverse("get-contextrecord"))
         # 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-contextrecord'))
+        response = c.get(reverse("get-contextrecord"))
         # 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)
 
     def test_own_modify(self):
         # no result when no authentification
         c = Client()
-        response = c.get(reverse('record_modify', args=[self.cr_2.pk]))
+        response = c.get(reverse("record_modify", args=[self.cr_2.pk]))
         self.assertRedirects(response, "/")
 
-        modif_url = '/record_modification/operation-record_modification'
+        modif_url = "/record_modification/operation-record_modification"
 
         # possession
         c = Client()
         c.login(username=self.alt_username, password=self.alt_password)
-        response = c.get(reverse('record_modify', args=[self.cr_2.pk]),
-                         follow=True)
+        response = c.get(reverse("record_modify", args=[self.cr_2.pk]), follow=True)
         self.assertRedirects(response, modif_url)
         response = c.get(modif_url)
 
         self.assertEqual(response.status_code, 200)
-        response = c.get(reverse('record_modify', args=[self.cr_1.pk]),
-                         follow=True)
+        response = c.get(reverse("record_modify", args=[self.cr_1.pk]), follow=True)
         self.assertRedirects(response, "/")
 
         # area filter
         c = Client()
         c.login(username=self.alt_username2, password=self.alt_password2)
-        response = c.get(reverse('record_modify', args=[self.cr_2.pk]),
-                         follow=True)
+        response = c.get(reverse("record_modify", args=[self.cr_2.pk]), follow=True)
         self.assertRedirects(response, modif_url)
         response = c.get(modif_url)
         self.assertEqual(response.status_code, 200)
-        response = c.get(reverse('record_modify', args=[self.cr_1.pk]),
-                         follow=True)
+        response = c.get(reverse("record_modify", args=[self.cr_1.pk]), follow=True)
         self.assertRedirects(response, "/")
 
 
@@ -885,17 +890,21 @@ class RecordRelationsTest(ContextRecordInit, TestCase):
 
     def test_relations(self):
         sym_rel_type = models.RelationType.objects.create(
-            symmetrical=True, txt_idx='sym')
+            symmetrical=True, txt_idx="sym"
+        )
         rel_type_1 = models.RelationType.objects.create(
-            symmetrical=False, txt_idx='rel_1')
+            symmetrical=False, txt_idx="rel_1"
+        )
         # cannot be symmetrical and have an inverse_relation
         with self.assertRaises(ValidationError):
             rel_test = models.RelationType.objects.create(
-                symmetrical=True, inverse_relation=rel_type_1, txt_idx='rel_3')
+                symmetrical=True, inverse_relation=rel_type_1, txt_idx="rel_3"
+            )
             rel_test.full_clean()
         # auto fill inverse relations
         rel_type_2 = models.RelationType.objects.create(
-            symmetrical=False, inverse_relation=rel_type_1, txt_idx='rel_2')
+            symmetrical=False, inverse_relation=rel_type_1, txt_idx="rel_2"
+        )
         self.assertEqual(rel_type_1.inverse_relation, rel_type_2)
 
         cr_1 = self.context_records[0]
@@ -904,119 +913,125 @@ class RecordRelationsTest(ContextRecordInit, TestCase):
         # inserting a new symmetrical relation automatically creates the same
         # relation for the second context record
         rel = models.RecordRelations.objects.create(
-            left_record=cr_1, right_record=cr_2, relation_type=sym_rel_type)
-        self.assertEqual(models.RecordRelations.objects.filter(
-            left_record=cr_2, right_record=cr_1,
-            relation_type=sym_rel_type).count(), 1)
+            left_record=cr_1, right_record=cr_2, relation_type=sym_rel_type
+        )
+        self.assertEqual(
+            models.RecordRelations.objects.filter(
+                left_record=cr_2, right_record=cr_1, relation_type=sym_rel_type
+            ).count(),
+            1,
+        )
 
         # removing one symmetrical relation removes the other
         rel.delete()
-        self.assertEqual(models.RecordRelations.objects.filter(
-            left_record=cr_2, right_record=cr_1,
-            relation_type=sym_rel_type).count(), 0)
+        self.assertEqual(
+            models.RecordRelations.objects.filter(
+                left_record=cr_2, right_record=cr_1, relation_type=sym_rel_type
+            ).count(),
+            0,
+        )
 
         # for non-symmetrical relation, adding one relation automatically
         # adds the inverse
         rel = models.RecordRelations.objects.create(
-            left_record=cr_1, right_record=cr_2, relation_type=rel_type_1)
-        self.assertEqual(models.RecordRelations.objects.filter(
-            left_record=cr_2, right_record=cr_1,
-            relation_type=rel_type_2).count(), 1)
+            left_record=cr_1, right_record=cr_2, relation_type=rel_type_1
+        )
+        self.assertEqual(
+            models.RecordRelations.objects.filter(
+                left_record=cr_2, right_record=cr_1, relation_type=rel_type_2
+            ).count(),
+            1,
+        )
 
 
 class ContextRecordWizardCreationTest(WizardTest, ContextRecordInit, TestCase):
     fixtures = OPERATION_TOWNS_FIXTURES
-    url_name = 'record_creation'
-    wizard_name = 'record_wizard'
+    url_name = "record_creation"
+    wizard_name = "record_wizard"
     steps = views.record_creation_steps
-    redirect_url = "/record_modification/selec-record_modification"\
-                   "?open_item={last_id}"
+    redirect_url = (
+        "/record_modification/selec-record_modification" "?open_item={last_id}"
+    )
     model = models.ContextRecord
     form_datas = [
         FormData(
             "Create a simple context record",
             form_datas={
-                'selec': {},
-                'general': {
-                    'label': "First"
-                },
-                'relations': [],
+                "selec": {},
+                "general": {"label": "First"},
+                "relations": [],
             },
-            ignored=('datings',
-                     'interpretation',
-                     )
+            ignored=(
+                "datings",
+                "interpretation",
+            ),
         ),
         FormData(
             "Create a context record with a relation and datings",
             form_datas={
-                'selec': {},
-                'general': {
-                    'label': "Second"
-                },
-                'relations': [],
-                'datings': []
+                "selec": {},
+                "general": {"label": "Second"},
+                "relations": [],
+                "datings": [],
             },
-            ignored=('interpretation',)
+            ignored=("interpretation",),
         ),
     ]
 
     def pre_wizard(self):
         profile, created = IshtarSiteProfile.objects.get_or_create(
-            slug='default', active=True)
+            slug="default", active=True
+        )
         profile.context_record = True
         profile.save()
 
         ope = self.get_default_operation()
         parcel = self.get_default_parcel()
         for form_data in self.form_datas:
-            form_data.set('selec', 'operation_id', ope.pk)
-            form_data.set('general', 'parcel', parcel.pk)
+            form_data.set("selec", "operation_id", ope.pk)
+            form_data.set("general", "parcel", parcel.pk)
 
-        self.related_cr = self.create_context_record(data={'operation': ope})[0]
+        self.related_cr = self.create_context_record(data={"operation": ope})[0]
 
         self.form_datas[1].append(
-            'relations',
-            {'right_record': self.related_cr.pk,
-             'relation_type': models.RelationType.objects.create(
-                 label="Test", symmetrical=False).pk}
+            "relations",
+            {
+                "right_record": self.related_cr.pk,
+                "relation_type": models.RelationType.objects.create(
+                    label="Test", symmetrical=False
+                ).pk,
+            },
         )
 
         period = models.Period.objects.all()[0].pk
-        self.form_datas[1].append(
-            'datings', {'period': period}
-        )
-        self.form_datas[1].append(
-            'datings', {'period': period}
-        )
+        self.form_datas[1].append("datings", {"period": period})
+        self.form_datas[1].append("datings", {"period": period})
 
         self.cr_nb = models.ContextRecord.objects.count()
         super(ContextRecordWizardCreationTest, self).pre_wizard()
 
     def post_wizard(self):
-        self.assertEqual(models.ContextRecord.objects.count(),
-                         self.cr_nb + 2)
-        self.assertEqual(self.related_cr.left_relations.count(),
-                         1)
+        self.assertEqual(models.ContextRecord.objects.count(), self.cr_nb + 2)
+        self.assertEqual(self.related_cr.left_relations.count(), 1)
         # identical datings, only one should be finaly save
-        cr = models.ContextRecord.objects.order_by('-pk')[0]
+        cr = models.ContextRecord.objects.order_by("-pk")[0]
         self.assertEqual(cr.datings.count(), 1)
 
 
 class AutocompleteTest(AutocompleteTestBase, TestCase):
     fixtures = CONTEXT_RECORD_FIXTURES
     models = [
-        AcItem(models.ContextRecord, 'autocomplete-contextrecord',
-               prepare_func="create_cr"),
+        AcItem(
+            models.ContextRecord, "autocomplete-contextrecord", prepare_func="create_cr"
+        ),
     ]
 
     def create_cr(self, base_name):
         ope, __ = models_ope.Operation.objects.get_or_create(
-            common_name="Test",
-            operation_type=models_ope.OperationType.objects.all()[0]
+            common_name="Test", operation_type=models_ope.OperationType.objects.all()[0]
         )
         item, __ = models.ContextRecord.objects.get_or_create(
-            operation=ope,
-            label=base_name
+            operation=ope, label=base_name
         )
         return item, None
 
@@ -1026,11 +1041,14 @@ class GraphGenerationTest(ContextRecordInit, TestCase):
 
     def setUp(self):
         self.sym_rel_type, __ = models.RelationType.objects.get_or_create(
-            symmetrical=True, txt_idx='sym', logical_relation='equal')
+            symmetrical=True, txt_idx="sym", logical_relation="equal"
+        )
         self.rel_type_below, __ = models.RelationType.objects.get_or_create(
-            symmetrical=False, txt_idx='below', logical_relation='below')
+            symmetrical=False, txt_idx="below", logical_relation="below"
+        )
         self.rel_type_above, __ = models.RelationType.objects.get_or_create(
-            symmetrical=False, txt_idx='above', logical_relation='above')
+            symmetrical=False, txt_idx="above", logical_relation="above"
+        )
         self.create_context_record({"label": "CR 1"})
         self.create_context_record({"label": "CR 2"})
         self.create_context_record({"label": "CR 3"})
@@ -1052,31 +1070,31 @@ class GraphGenerationTest(ContextRecordInit, TestCase):
         cr_2D = self.context_records[8]
 
         models.RecordRelations.objects.create(
-            left_record=cr_2, right_record=cr_2B,
-            relation_type=self.sym_rel_type)
+            left_record=cr_2, right_record=cr_2B, relation_type=self.sym_rel_type
+        )
 
         models.RecordRelations.objects.create(
-            left_record=cr_1, right_record=cr_2,
-            relation_type=self.rel_type_below)
+            left_record=cr_1, right_record=cr_2, relation_type=self.rel_type_below
+        )
         models.RecordRelations.objects.create(
-            left_record=cr_3, right_record=cr_2,
-            relation_type=self.rel_type_above)
+            left_record=cr_3, right_record=cr_2, relation_type=self.rel_type_above
+        )
         models.RecordRelations.objects.create(
-            left_record=cr_3, right_record=cr_4,
-            relation_type=self.rel_type_below)
+            left_record=cr_3, right_record=cr_4, relation_type=self.rel_type_below
+        )
 
         models.RecordRelations.objects.create(
-            left_record=cr_1B, right_record=cr_2B,
-            relation_type=self.rel_type_below)
+            left_record=cr_1B, right_record=cr_2B, relation_type=self.rel_type_below
+        )
         models.RecordRelations.objects.create(
-            left_record=cr_3B, right_record=cr_2B,
-            relation_type=self.rel_type_above)
+            left_record=cr_3B, right_record=cr_2B, relation_type=self.rel_type_above
+        )
         models.RecordRelations.objects.create(
-            left_record=cr_3B, right_record=cr_2C,
-            relation_type=self.rel_type_above)
+            left_record=cr_3B, right_record=cr_2C, relation_type=self.rel_type_above
+        )
         models.RecordRelations.objects.create(
-            left_record=cr_2D, right_record=cr_3B,
-            relation_type=self.rel_type_below)
+            left_record=cr_2D, right_record=cr_3B, relation_type=self.rel_type_below
+        )
 
     def test_gen_relation(self):
         generate_relation_graph(self.cr_2)
@@ -1146,5 +1164,3 @@ class GraphGenerationTest(ContextRecordInit, TestCase):
         self.assertNotIn('"CR 4"', content)
         self.assertNotIn('"CR 2C"', content)
         self.assertNotIn('"CR 2D"', content)
-
-
diff --git a/archaeological_context_records/urls.py b/archaeological_context_records/urls.py
index 434aa79f9..be3994821 100644
--- a/archaeological_context_records/urls.py
+++ b/archaeological_context_records/urls.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 # Copyright (C) 2010-2016 Étienne Loks  <etienne.loks_AT_peacefrogsDOTnet>
 
@@ -28,76 +28,145 @@ from archaeological_context_records import views
 # forms
 urlpatterns = [
     # Context records
-    url(r'record_search/(?P<step>.+)?$',
-        check_rights(['view_contextrecord', 'view_own_contextrecord'])(
-            views.record_search_wizard), name='record_search'),
-    url(r'contextrecord_search/(?P<step>.+)?$',
-        check_rights(['view_contextrecord', 'view_own_contextrecord'])(
-            views.record_search_wizard), name='contextrecord_search'),
-    url(r'record_creation/(?P<step>.+)?$',
-        check_rights(['add_contextrecord', 'add_own_contextrecord'])(
-            views.record_creation_wizard), name='record_creation'),
-    url(r'record_modification/(?P<step>.+)?$',
-        check_rights(['change_contextrecord', 'change_own_contextrecord'])(
-            views.record_modification_wizard), name='record_modification'),
-    url(r'record_modify/(?P<pk>.+)/$',
-        views.record_modify, name='record_modify'),
-    url(r'record_deletion/(?P<step>.+)?$',
-        check_rights(['change_contextrecord', 'change_own_contextrecord'])(
-            views.record_deletion_wizard), name='record_deletion'),
-    url(r'record_delete/(?P<pk>.+)/$',
-        views.record_delete, name='delete-contextrecord'),
-    url(r'autocomplete-contextrecord/$', views.autocomplete_contextrecord,
-        name='autocomplete-contextrecord'),
-    url(r'show-contextrecord(?:/(?P<pk>.+))?/(?P<type>.+)?$',
-        views.show_contextrecord, name=models.ContextRecord.SHOW_URL),
+    url(
+        r"record_search/(?P<step>.+)?$",
+        check_rights(["view_contextrecord", "view_own_contextrecord"])(
+            views.record_search_wizard
+        ),
+        name="record_search",
+    ),
+    url(
+        r"contextrecord_search/(?P<step>.+)?$",
+        check_rights(["view_contextrecord", "view_own_contextrecord"])(
+            views.record_search_wizard
+        ),
+        name="contextrecord_search",
+    ),
+    url(
+        r"record_creation/(?P<step>.+)?$",
+        check_rights(["add_contextrecord", "add_own_contextrecord"])(
+            views.record_creation_wizard
+        ),
+        name="record_creation",
+    ),
+    url(
+        r"record_modification/(?P<step>.+)?$",
+        check_rights(["change_contextrecord", "change_own_contextrecord"])(
+            views.record_modification_wizard
+        ),
+        name="record_modification",
+    ),
+    url(r"record_modify/(?P<pk>.+)/$", views.record_modify, name="record_modify"),
+    url(
+        r"record_deletion/(?P<step>.+)?$",
+        check_rights(["change_contextrecord", "change_own_contextrecord"])(
+            views.record_deletion_wizard
+        ),
+        name="record_deletion",
+    ),
+    url(
+        r"record_delete/(?P<pk>.+)/$", views.record_delete, name="delete-contextrecord"
+    ),
+    url(
+        r"autocomplete-contextrecord/$",
+        views.autocomplete_contextrecord,
+        name="autocomplete-contextrecord",
+    ),
+    url(
+        r"show-contextrecord(?:/(?P<pk>.+))?/(?P<type>.+)?$",
+        views.show_contextrecord,
+        name=models.ContextRecord.SHOW_URL,
+    ),
     # show-contextrecordrelation is only a view the id point to a context record
-    url(r'show-contextrecord(?:/(?P<pk>.+))?/(?P<type>.+)?$',
-        views.show_contextrecord, name='show-contextrecordrelation'),
-    url(r'show-historized-contextrecord/(?P<pk>.+)?/(?P<date>.+)?$',
-        views.show_contextrecord, name='show-historized-contextrecord'),
-    url(r'revert-contextrecord/(?P<pk>.+)/(?P<date>.+)$',
-        views.revert_contextrecord, name='revert-contextrecord'),
-    url(r'generate-relation-image-contextrecord/(?P<pk>.+)/('
-        r'?P<type>(below)|(above)|(full))?',
+    url(
+        r"show-contextrecord(?:/(?P<pk>.+))?/(?P<type>.+)?$",
+        views.show_contextrecord,
+        name="show-contextrecordrelation",
+    ),
+    url(
+        r"show-historized-contextrecord/(?P<pk>.+)?/(?P<date>.+)?$",
+        views.show_contextrecord,
+        name="show-historized-contextrecord",
+    ),
+    url(
+        r"revert-contextrecord/(?P<pk>.+)/(?P<date>.+)$",
+        views.revert_contextrecord,
+        name="revert-contextrecord",
+    ),
+    url(
+        r"generate-relation-image-contextrecord/(?P<pk>.+)/("
+        r"?P<type>(below)|(above)|(full))?",
         views.GenerateRelationImage.as_view(),
-        name='generate-relation-image-contextrecord'),
-    url(r'get-contextrecord/own/(?P<type>.+)?$', views.get_contextrecord,
-        name='get-own-contextrecord', kwargs={'force_own': True}),
-    url(r'get-contextrecord/(?P<type>.+)?$', views.get_contextrecord,
-        name='get-contextrecord'),
-    url(r'get-contextrecord-for-ope/own/(?P<type>.+)?$',
+        name="generate-relation-image-contextrecord",
+    ),
+    url(
+        r"get-contextrecord/own/(?P<type>.+)?$",
+        views.get_contextrecord,
+        name="get-own-contextrecord",
+        kwargs={"force_own": True},
+    ),
+    url(
+        r"get-contextrecord/(?P<type>.+)?$",
+        views.get_contextrecord,
+        name="get-contextrecord",
+    ),
+    url(
+        r"get-contextrecord-for-ope/own/(?P<type>.+)?$",
         views.get_contextrecord_for_ope,
-        name='get-own-contextrecord-for-ope', kwargs={'force_own': True}),
-    url(r'get-contextrecord-for-ope/(?P<type>.+)?$',
+        name="get-own-contextrecord-for-ope",
+        kwargs={"force_own": True},
+    ),
+    url(
+        r"get-contextrecord-for-ope/(?P<type>.+)?$",
         views.get_contextrecord_for_ope,
-        name='get-contextrecord-for-ope'),
-    url(r'get-contextrecord-full/own/(?P<type>.+)?$',
-        views.get_contextrecord, name='get-own-contextrecord-full',
-        kwargs={'full': True, 'force_own': True}),
-    url(r'get-contextrecord-full/(?P<type>.+)?$',
-        views.get_contextrecord, name='get-contextrecord-full',
-        kwargs={'full': True}),
-    url(r'get-contextrecord-shortcut/(?P<type>.+)?$',
-        views.get_contextrecord, name='get-contextrecord-shortcut',
-        kwargs={'full': 'shortcut'}),
-    url(r'get-contextrecordrelation/(?P<type>.+)?$',
-        views.get_contextrecordrelation, name='get-contextrecordrelation'),
-    url(r'get-contextrecordrelationdetail/(?P<type>.+)?$',
+        name="get-contextrecord-for-ope",
+    ),
+    url(
+        r"get-contextrecord-full/own/(?P<type>.+)?$",
+        views.get_contextrecord,
+        name="get-own-contextrecord-full",
+        kwargs={"full": True, "force_own": True},
+    ),
+    url(
+        r"get-contextrecord-full/(?P<type>.+)?$",
+        views.get_contextrecord,
+        name="get-contextrecord-full",
+        kwargs={"full": True},
+    ),
+    url(
+        r"get-contextrecord-shortcut/(?P<type>.+)?$",
+        views.get_contextrecord,
+        name="get-contextrecord-shortcut",
+        kwargs={"full": "shortcut"},
+    ),
+    url(
+        r"get-contextrecordrelation/(?P<type>.+)?$",
+        views.get_contextrecordrelation,
+        name="get-contextrecordrelation",
+    ),
+    url(
+        r"get-contextrecordrelationdetail/(?P<type>.+)?$",
         views.get_contextrecordrelationdetail,
-        name='get-contextrecordrelationdetail'),
-
-    url(r'^operation-qa-contextrecord/(?P<pks>[0-9]+)/$',
-        check_rights(['add_contextrecord', 'add_own_contextrecord'])(
-            views.QAOperationContextRecordView.as_view()),
-        name='operation-qa-contextrecord'),
-
-    url(r'^contextrecord-qa-lock/(?P<pks>[0-9-]+)?/$',
-        views.QAContextRecordLockView.as_view(), name='contextrecord-qa-lock',
-        kwargs={"model": models.ContextRecord}),
-    url(r'^contextrecord-qa-duplicate/(?P<pks>[0-9-]+)?/$',
-        check_rights(['change_contextrecord', 'change_own_contextrecord'])(
-            views.QAContextRecordDuplicateFormView.as_view()),
-        name='contextrecord-qa-duplicate'),
-
+        name="get-contextrecordrelationdetail",
+    ),
+    url(
+        r"^operation-qa-contextrecord/(?P<pks>[0-9]+)/$",
+        check_rights(["add_contextrecord", "add_own_contextrecord"])(
+            views.QAOperationContextRecordView.as_view()
+        ),
+        name="operation-qa-contextrecord",
+    ),
+    url(
+        r"^contextrecord-qa-lock/(?P<pks>[0-9-]+)?/$",
+        views.QAContextRecordLockView.as_view(),
+        name="contextrecord-qa-lock",
+        kwargs={"model": models.ContextRecord},
+    ),
+    url(
+        r"^contextrecord-qa-duplicate/(?P<pks>[0-9-]+)?/$",
+        check_rights(["change_contextrecord", "change_own_contextrecord"])(
+            views.QAContextRecordDuplicateFormView.as_view()
+        ),
+        name="contextrecord-qa-duplicate",
+    ),
 ]
diff --git a/archaeological_context_records/views.py b/archaeological_context_records/views.py
index 2de60dc2c..568d2a4f2 100644
--- a/archaeological_context_records/views.py
+++ b/archaeological_context_records/views.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 # Copyright (C) 2010-2016  Étienne Loks  <etienne.loks_AT_peacefrogsDOTnet>
 
@@ -34,139 +34,163 @@ from archaeological_operations.views import site_extra_context
 from archaeological_context_records import forms
 from ishtar_common.utils import put_session_message
 
-from ishtar_common.views import IshtarMixin, LoginRequiredMixin, QAItemForm, \
-    QABaseLockView, wizard_is_available
-from ishtar_common.views_item import display_item, get_item, show_item, \
-    revert_item
+from ishtar_common.views import (
+    IshtarMixin,
+    LoginRequiredMixin,
+    QAItemForm,
+    QABaseLockView,
+    wizard_is_available,
+)
+from ishtar_common.views_item import display_item, get_item, show_item, revert_item
 from archaeological_context_records import wizards
 
 show_contextrecord = show_item(
-    models.ContextRecord, 'contextrecord',
-    extra_dct=site_extra_context
+    models.ContextRecord, "contextrecord", extra_dct=site_extra_context
 )
 revert_contextrecord = revert_item(models.ContextRecord)
 
 
 def autocomplete_contextrecord(request):
-    if (not request.user.has_perm(
-            'archaeological_context_records.view_contextrecord',
-            models.ContextRecord)
-        and not request.user.has_perm(
-            'archaeological_context_records.view_own_contextrecord',
-            models.ArchaeologicalSite)):
-        return HttpResponse(content_type='text/plain')
-    if not request.GET.get('term'):
-        return HttpResponse(content_type='text/plain')
-    q = request.GET.get('term')
+    if not request.user.has_perm(
+        "archaeological_context_records.view_contextrecord", models.ContextRecord
+    ) and not request.user.has_perm(
+        "archaeological_context_records.view_own_contextrecord",
+        models.ArchaeologicalSite,
+    ):
+        return HttpResponse(content_type="text/plain")
+    if not request.GET.get("term"):
+        return HttpResponse(content_type="text/plain")
+    q = request.GET.get("term")
     query = Q()
-    if request.GET.get('operation__pk'):
-        query = Q(operation__pk=request.GET.get('operation__pk'))
-    for q in q.split(' '):
-        qt = Q(parcel__section__icontains=q) | \
-            Q(parcel__parcel_number__icontains=q) | \
-            Q(cached_label__icontains=q) | Q(label__icontains=q)
+    if request.GET.get("operation__pk"):
+        query = Q(operation__pk=request.GET.get("operation__pk"))
+    for q in q.split(" "):
+        qt = (
+            Q(parcel__section__icontains=q)
+            | Q(parcel__parcel_number__icontains=q)
+            | Q(cached_label__icontains=q)
+            | Q(label__icontains=q)
+        )
         query = query & qt
     limit = 15
-    items = models.ContextRecord.objects\
-        .filter(query).order_by('parcel__section', 'parcel__parcel_number',
-                                'label')[:limit]
-    data = json.dumps([{'id': item.pk,
-                        'value': str(item)[:60]}
-                       for item in items])
-    return HttpResponse(data, content_type='text/plain')
+    items = models.ContextRecord.objects.filter(query).order_by(
+        "parcel__section", "parcel__parcel_number", "label"
+    )[:limit]
+    data = json.dumps([{"id": item.pk, "value": str(item)[:60]} for item in items])
+    return HttpResponse(data, content_type="text/plain")
 
 
 get_contextrecord = get_item(
     models.ContextRecord,
-    'get_contextrecord', 'contextrecord',
-    search_form=forms.RecordSelect
+    "get_contextrecord",
+    "contextrecord",
+    search_form=forms.RecordSelect,
 )
 get_contextrecord_for_ope = get_item(
     models.ContextRecord,
-    'get_contextrecord', 'contextrecord',
-    own_table_cols=models.ContextRecord.TABLE_COLS_FOR_OPE)
+    "get_contextrecord",
+    "contextrecord",
+    own_table_cols=models.ContextRecord.TABLE_COLS_FOR_OPE,
+)
 
 get_contextrecordrelation = get_item(
-    models.RecordRelationView, 'get_contextrecordrelation',
-    'contextrecordrelation', specific_perms=['view_recordrelation'],
+    models.RecordRelationView,
+    "get_contextrecordrelation",
+    "contextrecordrelation",
+    specific_perms=["view_recordrelation"],
     do_not_deduplicate=True,
-    extra_request_keys=models.RecordRelationView.EXTRA_REQUEST_KEYS
+    extra_request_keys=models.RecordRelationView.EXTRA_REQUEST_KEYS,
 )
 
 get_contextrecordrelationdetail = get_item(
-    models.RecordRelations, 'get_contextrecordrelationdetail',
-    'contextrecordrelationdetail', specific_perms=['view_recordrelation'])
+    models.RecordRelations,
+    "get_contextrecordrelationdetail",
+    "contextrecordrelationdetail",
+    specific_perms=["view_recordrelation"],
+)
 
-record_search_wizard = wizards.RecordSearch.as_view([
-    ('general-record_search', forms.RecordFormSelection)],
+record_search_wizard = wizards.RecordSearch.as_view(
+    [("general-record_search", forms.RecordFormSelection)],
     label=_("Context record search"),
-    url_name='record_search',)
+    url_name="record_search",
+)
 
 record_creation_steps = [
-    ('selec-record_creation', forms.OperationRecordFormSelection),
-    ('general-record_creation', forms.RecordFormGeneral),
-    ('datings-record_creation', forms.DatingFormSet),
-    ('interpretation-record_creation', forms.RecordFormInterpretation),
-    ('relations-record_creation', forms.RecordRelationsFormSet),
-    ('final-record_creation', forms.FinalForm)
+    ("selec-record_creation", forms.OperationRecordFormSelection),
+    ("general-record_creation", forms.RecordFormGeneral),
+    ("datings-record_creation", forms.DatingFormSet),
+    ("interpretation-record_creation", forms.RecordFormInterpretation),
+    ("relations-record_creation", forms.RecordRelationsFormSet),
+    ("final-record_creation", forms.FinalForm),
 ]
 
 record_creation_wizard = wizards.RecordWizard.as_view(
     record_creation_steps,
     label=_("New context record"),
-    url_name='record_creation',
+    url_name="record_creation",
 )
 
 record_modification_steps = [
-    ('selec-record_modification', forms.RecordFormSelection),
-    ('operation-record_modification', forms.OperationFormSelection),
-    ('general-record_modification', forms.RecordFormGeneral),
-    ('datings-record_modification', forms.DatingFormSet),
-    ('interpretation-record_modification', forms.RecordFormInterpretation),
-    ('relations-record_modification', forms.RecordRelationsFormSet),
-    ('final-record_modification', forms.FinalForm)
+    ("selec-record_modification", forms.RecordFormSelection),
+    ("operation-record_modification", forms.OperationFormSelection),
+    ("general-record_modification", forms.RecordFormGeneral),
+    ("datings-record_modification", forms.DatingFormSet),
+    ("interpretation-record_modification", forms.RecordFormInterpretation),
+    ("relations-record_modification", forms.RecordRelationsFormSet),
+    ("final-record_modification", forms.FinalForm),
 ]
 
 record_modification_wizard = wizards.RecordModifWizard.as_view(
     record_modification_steps,
     label=_("Context record modification"),
-    url_name='record_modification',
+    url_name="record_modification",
 )
 
 
 def record_modify(request, pk):
-    if not wizard_is_available(record_modification_wizard, request,
-                               models.ContextRecord, pk):
+    if not wizard_is_available(
+        record_modification_wizard, request, models.ContextRecord, pk
+    ):
         return HttpResponseRedirect("/")
 
     wizards.RecordModifWizard.session_set_value(
-        request, 'selec-record_modification', 'pk', pk, reset=True)
-    return redirect(reverse('record_modification',
-                    kwargs={'step': 'operation-record_modification'}))
-
-record_deletion_wizard = wizards.RecordDeletionWizard.as_view([
-    ('selec-record_deletion', forms.RecordFormMultiSelection),
-    ('final-record_deletion', forms.RecordDeletionForm)],
+        request, "selec-record_modification", "pk", pk, reset=True
+    )
+    return redirect(
+        reverse("record_modification", kwargs={"step": "operation-record_modification"})
+    )
+
+
+record_deletion_wizard = wizards.RecordDeletionWizard.as_view(
+    [
+        ("selec-record_deletion", forms.RecordFormMultiSelection),
+        ("final-record_deletion", forms.RecordDeletionForm),
+    ],
     label=_("Context record deletion"),
-    url_name='record_deletion',)
+    url_name="record_deletion",
+)
 
 
 def record_delete(request, pk):
-    if not wizard_is_available(record_deletion_wizard, request,
-                               models.ContextRecord, pk):
+    if not wizard_is_available(
+        record_deletion_wizard, request, models.ContextRecord, pk
+    ):
         return HttpResponseRedirect("/")
 
     wizards.RecordDeletionWizard.session_set_value(
-        request, 'selec-record_deletion', 'pks', pk, reset=True)
-    return redirect(reverse('record_deletion',
-                            kwargs={'step': 'final-record_deletion'}))
+        request, "selec-record_deletion", "pks", pk, reset=True
+    )
+    return redirect(
+        reverse("record_deletion", kwargs={"step": "final-record_deletion"})
+    )
 
 
 def reset_wizards(request):
     for wizard_class, url_name in (
-            (wizards.RecordWizard, 'record_creation'),
-            (wizards.RecordModifWizard, 'record_modification'),
-            (wizards.RecordDeletionWizard, 'record_deletion')):
+        (wizards.RecordWizard, "record_creation"),
+        (wizards.RecordModifWizard, "record_modification"),
+        (wizards.RecordDeletionWizard, "record_deletion"),
+    ):
         wizard_class.session_reset(request, url_name)
 
 
@@ -176,28 +200,31 @@ class GenerateRelationImage(IshtarMixin, LoginRequiredMixin, RedirectView):
 
     def get_redirect_url(self, *args, **kwargs):
         if self.upper_item:
-            return reverse(
-                'display-item',
-                args=[self.upper_model.SLUG, self.upper_item.pk]) + "#cr"
-        return reverse('display-item',
-                       args=[self.model.SLUG, self.item.pk]) + "#relations"
+            return (
+                reverse(
+                    "display-item", args=[self.upper_model.SLUG, self.upper_item.pk]
+                )
+                + "#cr"
+            )
+        return (
+            reverse("display-item", args=[self.model.SLUG, self.item.pk]) + "#relations"
+        )
 
     def get(self, request, *args, **kwargs):
         self.upper_item = None
         render_type = kwargs.get("type", None)
         if render_type == "full" and self.upper_model:
             try:
-                self.upper_item = self.upper_model.objects.get(pk=kwargs['pk'])
+                self.upper_item = self.upper_model.objects.get(pk=kwargs["pk"])
             except self.model.DoesNotExist:
                 raise Http404()
             q = self.upper_item.context_record_relations_q()
             if not q.count():
-                return super(GenerateRelationImage, self).get(request, *args,
-                                                              **kwargs)
+                return super(GenerateRelationImage, self).get(request, *args, **kwargs)
             self.item = q.all()[0].left_record
         else:
             try:
-                self.item = self.model.objects.get(pk=kwargs['pk'])
+                self.item = self.model.objects.get(pk=kwargs["pk"])
             except self.model.DoesNotExist:
                 raise Http404()
         render_above, render_below, full = True, True, False
@@ -208,21 +235,25 @@ class GenerateRelationImage(IshtarMixin, LoginRequiredMixin, RedirectView):
         elif render_type == "full":
             full = True
         self.item.generate_relation_image(
-            render_below=render_below, render_above=render_above, full=full)
+            render_below=render_below, render_above=render_above, full=full
+        )
         return super(GenerateRelationImage, self).get(request, *args, **kwargs)
 
 
 class QAOperationContextRecordView(QAItemForm):
-    template_name = 'ishtar/forms/qa_operation_contextrecord.html'
+    template_name = "ishtar/forms/qa_operation_contextrecord.html"
     model = Operation
     form_class = forms.QAOperationCR
     page_name = _("Context record")
 
     def get_quick_action(self):
         return QuickAction(
-            url="operation-qa-contextrecord", icon_class="fa fa-plus",
-            text=_("Add context record"), target="one",
-            rights=['add_contextrecord', 'add_own_contextrecord'])
+            url="operation-qa-contextrecord",
+            icon_class="fa fa-plus",
+            text=_("Add context record"),
+            target="one",
+            rights=["add_contextrecord", "add_own_contextrecord"],
+        )
 
     def form_valid(self, form):
         form.save(self.items)
@@ -235,7 +266,7 @@ class QAContextRecordLockView(QABaseLockView):
 
 
 class QAContextRecordDuplicateFormView(QAItemForm):
-    template_name = 'ishtar/forms/qa_contextrecord_duplicate.html'
+    template_name = "ishtar/forms/qa_contextrecord_duplicate.html"
     model = models.ContextRecord
     page_name = _("Duplicate")
     form_class = forms.QAContextRecordDuplicateForm
@@ -243,7 +274,7 @@ class QAContextRecordDuplicateFormView(QAItemForm):
 
     def get_form_kwargs(self):
         kwargs = super(QAContextRecordDuplicateFormView, self).get_form_kwargs()
-        kwargs['user'] = self.request.user
+        kwargs["user"] = self.request.user
         return kwargs
 
     def form_valid(self, form):
@@ -251,8 +282,7 @@ class QAContextRecordDuplicateFormView(QAItemForm):
         return HttpResponseRedirect(reverse("success"))
 
     def get_context_data(self, **kwargs):
-        data = super(QAContextRecordDuplicateFormView, self).get_context_data(
-            **kwargs)
-        data['action_name'] = _("Duplicate")
+        data = super(QAContextRecordDuplicateFormView, self).get_context_data(**kwargs)
+        data["action_name"] = _("Duplicate")
         data["operation"] = self.items[0].operation
         return data
diff --git a/archaeological_context_records/wizards.py b/archaeological_context_records/wizards.py
index 53f13c481..da1364b28 100644
--- a/archaeological_context_records/wizards.py
+++ b/archaeological_context_records/wizards.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 # Copyright (C) 2012-2013  Étienne Loks  <etienne.loks_AT_peacefrogsDOTnet>
 
@@ -32,15 +32,15 @@ class RecordSearch(SearchWizard):
 class RecordWizard(Wizard):
     model = models.ContextRecord
     edit = False
-    wizard_done_window = reverse_lazy('show-contextrecord')
-    relations_step_key = 'relations'
-    redirect_url = 'record_modification'
+    wizard_done_window = reverse_lazy("show-contextrecord")
+    relations_step_key = "relations"
+    redirect_url = "record_modification"
 
     def get_template_names(self):
         templates = super(RecordWizard, self).get_template_names()
         current_step = self.steps.current
         if current_step.startswith(self.relations_step_key):
-            templates = ['ishtar/wizard/relations_wizard.html'] + templates
+            templates = ["ishtar/wizard/relations_wizard.html"] + templates
         return templates
 
     def get_current_operation(self):
@@ -48,23 +48,21 @@ class RecordWizard(Wizard):
         if not step:
             return
         # manage manualy on creation
-        if step.endswith('_creation'):  # an operation has been selected
-            main_form_key = 'selec-' + self.url_name
+        if step.endswith("_creation"):  # an operation has been selected
+            main_form_key = "selec-" + self.url_name
             try:
-                idx = int(self.session_get_value(
-                    main_form_key, 'operation_id'))
+                idx = int(self.session_get_value(main_form_key, "operation_id"))
                 current_ope = models.Operation.objects.get(pk=idx)
                 return current_ope
-            except(TypeError, ValueError, ObjectDoesNotExist):
+            except (TypeError, ValueError, ObjectDoesNotExist):
                 pass
         else:
-            ope_form_key = 'operation-' + self.url_name
+            ope_form_key = "operation-" + self.url_name
             try:
-                idx = int(self.session_get_value(
-                    ope_form_key, 'operation'))
+                idx = int(self.session_get_value(ope_form_key, "operation"))
                 current_ope = models.Operation.objects.get(pk=idx)
                 return current_ope
-            except(TypeError, ValueError, ObjectDoesNotExist):
+            except (TypeError, ValueError, ObjectDoesNotExist):
                 pass
         current_cr = self.get_current_object()
         if current_cr:
@@ -77,9 +75,9 @@ class RecordWizard(Wizard):
         context = super(RecordWizard, self).get_context_data(form)
 
         operation = self.get_current_operation()
-        if not operation or self.steps.current.startswith('selec-'):
+        if not operation or self.steps.current.startswith("selec-"):
             return context
-        context['reminders'] = ((_("Operation"), str(operation)),)
+        context["reminders"] = ((_("Operation"), str(operation)),)
         return context
 
     def get_form(self, step=None, data=None, files=None):
@@ -96,30 +94,28 @@ class RecordWizard(Wizard):
         form = self.get_form_list()[step]
 
         # general_form_key = 'general-' + self.url_name
-        if step.startswith('general-'):
-            if step.endswith('_creation'):  # an operation has been selected
-                main_form_key = 'selec-' + self.url_name
+        if step.startswith("general-"):
+            if step.endswith("_creation"):  # an operation has been selected
+                main_form_key = "selec-" + self.url_name
                 try:
-                    idx = int(self.session_get_value(main_form_key,
-                                                     'operation_id'))
+                    idx = int(self.session_get_value(main_form_key, "operation_id"))
                     current_obj = models.Operation.objects.get(pk=idx)
-                    data['operation'] = current_obj
-                except(TypeError, ValueError, ObjectDoesNotExist):
+                    data["operation"] = current_obj
+                except (TypeError, ValueError, ObjectDoesNotExist):
                     pass
-            elif step.endswith('_modification'):
-                ope_form_key = 'operation-' + self.url_name
+            elif step.endswith("_modification"):
+                ope_form_key = "operation-" + self.url_name
                 try:
-                    idx = int(self.session_get_value(ope_form_key,
-                                                     'operation'))
+                    idx = int(self.session_get_value(ope_form_key, "operation"))
                     current_obj = models.Operation.objects.get(pk=idx)
-                    data['operation'] = current_obj
-                except(TypeError, ValueError, ObjectDoesNotExist):
+                    data["operation"] = current_obj
+                except (TypeError, ValueError, ObjectDoesNotExist):
                     pass
             else:
                 current_object = self.get_current_object()
-                data['context_record'] = current_object
-        elif step.startswith('relations') and hasattr(form, 'management_form'):
-            data['CONTEXT_RECORDS'] = self.get_other_context_records()
+                data["context_record"] = current_object
+        elif step.startswith("relations") and hasattr(form, "management_form"):
+            data["CONTEXT_RECORDS"] = self.get_other_context_records()
         form = super(RecordWizard, self).get_form(step, data, files)
         return form
 
@@ -137,11 +133,10 @@ class RecordWizard(Wizard):
 class RecordModifWizard(RecordWizard):
     modification = True
     model = models.ContextRecord
-    filter_owns = {'selec-record_modification': ['pk']}
+    filter_owns = {"selec-record_modification": ["pk"]}
 
     def get_form_kwargs(self, step, **kwargs):
-        kwargs = super(RecordModifWizard, self).get_form_kwargs(
-            step, **kwargs)
+        kwargs = super(RecordModifWizard, self).get_form_kwargs(step, **kwargs)
         if step != "relations-record_modification":
             return kwargs
         kwargs["left_record"] = self.get_current_object()
@@ -150,9 +145,24 @@ class RecordModifWizard(RecordWizard):
 
 class RecordDeletionWizard(MultipleDeletionWizard):
     model = models.ContextRecord
-    fields = ['label', 'parcel', 'description', 'length', 'width', 'thickness',
-              'depth', 'location', 'datings', 'units', 'documentations',
-              'filling', 'interpretation', 'taq', 'taq_estimated', 'tpq',
-              'tpq_estimated']
-    filter_owns = {'selec-record_deletion': ['pks']}
+    fields = [
+        "label",
+        "parcel",
+        "description",
+        "length",
+        "width",
+        "thickness",
+        "depth",
+        "location",
+        "datings",
+        "units",
+        "documentations",
+        "filling",
+        "interpretation",
+        "taq",
+        "taq_estimated",
+        "tpq",
+        "tpq_estimated",
+    ]
+    filter_owns = {"selec-record_deletion": ["pks"]}
     redirect_url = "record_deletion"