Format - black: ishtar_common

1 files changed, 643 insertions, 490 deletions

diff --git a/ishtar_common/admin.py b/ishtar_common/admin.py
index 4cae9e02c..bbd61f14b 100644
--- a/ishtar_common/admin.py
+++ b/ishtar_common/admin.py
@@ -30,8 +30,7 @@ from rest_framework.authtoken.admin import TokenAdmin
 from rest_framework.authtoken.models import Token
 
 from ajax_select import make_ajax_form
-from ajax_select.fields import AutoCompleteSelectField, \
-    AutoCompleteSelectMultipleField
+from ajax_select.fields import AutoCompleteSelectField, AutoCompleteSelectMultipleField
 
 from django.conf import settings
 from django.conf.urls import url
@@ -49,8 +48,13 @@ from django.contrib.gis.geos.error import GEOSException
 from django.core.cache import cache
 from django.core.serializers import serialize
 from django.core.urlresolvers import reverse
-from django.db.models.fields import BooleanField, IntegerField, FloatField, \
-    CharField, FieldDoesNotExist
+from django.db.models.fields import (
+    BooleanField,
+    IntegerField,
+    FloatField,
+    CharField,
+    FieldDoesNotExist,
+)
 from django.db.models.fields.related import ForeignKey
 from django.forms import BaseInlineFormSet
 from django.http import HttpResponseRedirect, HttpResponse
@@ -69,14 +73,15 @@ from ishtar_common.utils import get_cache, create_slug
 
 from ishtar_common import forms as common_forms
 from ishtar_common.serializers import restore_serialized, IMPORT_MODEL_LIST
-from ishtar_common.serializers_utils import generic_get_results, \
-    serialization_info
+from ishtar_common.serializers_utils import generic_get_results, serialization_info
 from archaeological_files import forms as file_forms
 from archaeological_files_pdl import forms as file_pdl_forms
 from archaeological_operations import forms as operation_forms
 from archaeological_context_records import forms as context_record_forms
-from archaeological_finds import forms as find_forms, \
-    forms_treatments as treatment_forms
+from archaeological_finds import (
+    forms as find_forms,
+    forms_treatments as treatment_forms,
+)
 from archaeological_warehouse import forms as warehouse_forms
 
 from ishtar_common.tasks import launch_export, launch_import
@@ -85,16 +90,22 @@ from ishtar_common.tasks import launch_export, launch_import
 csrf_protect_m = method_decorator(csrf_protect)
 
 
-ISHTAR_FORMS = [common_forms, file_pdl_forms, file_forms, operation_forms,
-                context_record_forms, find_forms, treatment_forms,
-                warehouse_forms]
+ISHTAR_FORMS = [
+    common_forms,
+    file_pdl_forms,
+    file_forms,
+    operation_forms,
+    context_record_forms,
+    find_forms,
+    treatment_forms,
+    warehouse_forms,
+]
 
 
 class ImportGenericForm(forms.Form):
     csv_file = forms.FileField(
         _("CSV file"),
-        help_text=_("Only unicode encoding is managed - convert your"
-                    " file first")
+        help_text=_("Only unicode encoding is managed - convert your" " file first"),
     )
 
 
@@ -102,28 +113,35 @@ def change_value(attribute, value, description):
     """
     Action to change a specific value in a list
     """
+
     def _change_value(modeladmin, request, queryset):
-        for obj in queryset.order_by('pk'):
+        for obj in queryset.order_by("pk"):
             setattr(obj, attribute, value)
             obj.save()
-        url = reverse(
-            'admin:%s_%s_changelist' % (
-                modeladmin.model._meta.app_label,
-                modeladmin.model._meta.model_name)
-        ) + '?' + urllib.parse.urlencode(request.GET)
+        url = (
+            reverse(
+                "admin:%s_%s_changelist"
+                % (modeladmin.model._meta.app_label, modeladmin.model._meta.model_name)
+            )
+            + "?"
+            + urllib.parse.urlencode(request.GET)
+        )
         return HttpResponseRedirect(url)
+
     _change_value.short_description = description
     _change_value.__name__ = str(slugify(description))
     return _change_value
 
 
-def export_as_csv_action(description=_("Export selected as CSV file"),
-                         fields=None, exclude=None, header=True):
+def export_as_csv_action(
+    description=_("Export selected as CSV file"), fields=None, exclude=None, header=True
+):
     """
     This function returns an export csv action
     'fields' and 'exclude' work like in django ModelForm
     'header' is whether or not to output the column names as the first row
     """
+
     def export_as_csv(modeladmin, request, queryset):
         """
         Generic csv export admin action.
@@ -138,21 +156,22 @@ def export_as_csv_action(description=_("Export selected as CSV file"),
             excludeset = set(exclude)
             field_names = field_names - excludeset
 
-        response = HttpResponse(content_type='text/csv')
-        response['Content-Disposition'] = 'attachment; filename=%s.csv' % \
-            str(opts).replace('.', '_')
+        response = HttpResponse(content_type="text/csv")
+        response["Content-Disposition"] = "attachment; filename=%s.csv" % str(
+            opts
+        ).replace(".", "_")
 
         writer = csv.writer(response)
         if header:
             writer.writerow(list(field_names))
-        for obj in queryset.order_by('pk'):
+        for obj in queryset.order_by("pk"):
             row = []
             for field in field_names:
                 value = getattr(obj, field)
-                if hasattr(value, 'txt_idx'):
-                    value = getattr(value, 'txt_idx')
-                elif hasattr(value, 'slug'):
-                    value = getattr(value, 'txt_idx')
+                if hasattr(value, "txt_idx"):
+                    value = getattr(value, "txt_idx")
+                elif hasattr(value, "slug"):
+                    value = getattr(value, "txt_idx")
                 elif value is None:
                     value = ""
                 else:
@@ -161,24 +180,30 @@ def export_as_csv_action(description=_("Export selected as CSV file"),
 
             writer.writerow(row)
         return response
+
     export_as_csv.short_description = description
     return export_as_csv
 
 
 def export_as_geojson_action(
-        geometry_field, description=_("Export selected as GeoJSON file"),
-        fields=None, exclude=None):
+    geometry_field,
+    description=_("Export selected as GeoJSON file"),
+    fields=None,
+    exclude=None,
+):
     """
     This function returns an export GeoJSON action
     'fields' work like in django ModelForm
     """
+
     def export_as_geojson(modeladmin, request, queryset):
         """
         Generic zipped geojson export admin action.
         """
         opts = modeladmin.model._meta
-        field_names = set([field.name for field in opts.fields if
-                           field.name != geometry_field])
+        field_names = set(
+            [field.name for field in opts.fields if field.name != geometry_field]
+        )
         if fields:
             fieldset = set(fields)
             field_names = field_names & fieldset
@@ -186,11 +211,14 @@ def export_as_geojson_action(
             excludeset = set(exclude)
             field_names = field_names - excludeset
 
-        basename = str(opts).replace('.', '_')
+        basename = str(opts).replace(".", "_")
 
         geojson = serialize(
-            'geojson', queryset.order_by('pk'), geometry_field=geometry_field,
-            fields=field_names).encode("utf-8")
+            "geojson",
+            queryset.order_by("pk"),
+            geometry_field=geometry_field,
+            fields=field_names,
+        ).encode("utf-8")
         in_memory = BytesIO()
         zip = zipfile.ZipFile(in_memory, "a")
         zip.writestr(basename + ".geojson", geojson)
@@ -199,13 +227,12 @@ def export_as_geojson_action(
         for file in zip.filelist:
             file.create_system = 0
         zip.close()
-        response = HttpResponse(content_type='application/zip')
-        response['Content-Disposition'] = 'attachment; filename={}.zip'.format(
-            basename
-        )
+        response = HttpResponse(content_type="application/zip")
+        response["Content-Disposition"] = "attachment; filename={}.zip".format(basename)
         in_memory.seek(0)
         response.write(in_memory.read())
         return response
+
     export_as_geojson.short_description = description
     return export_as_geojson
 
@@ -218,9 +245,9 @@ def serialize_action(dir_name, model_list):
             modellist = [modeladmin.model]
         opts = modeladmin.model._meta
         result = generic_get_results(
-            modellist, dir_name,
-            result_queryset={opts.object_name: queryset})
-        basename = str(opts).replace('.', '_')
+            modellist, dir_name, result_queryset={opts.object_name: queryset}
+        )
+        basename = str(opts).replace(".", "_")
         in_memory = BytesIO()
         zip = zipfile.ZipFile(in_memory, "a")
         for key in result.keys():
@@ -234,13 +261,12 @@ def serialize_action(dir_name, model_list):
         for file in zip.filelist:
             file.create_system = 0
         zip.close()
-        response = HttpResponse(content_type='application/zip')
-        response['Content-Disposition'] = 'attachment; filename={}.zip'.format(
-            basename
-        )
+        response = HttpResponse(content_type="application/zip")
+        response["Content-Disposition"] = "attachment; filename={}.zip".format(basename)
         in_memory.seek(0)
         response.write(in_memory.read())
         return response
+
     return _serialize_action
 
 
@@ -263,24 +289,27 @@ class MergeForm(forms.Form):
 class MergeActionAdmin:
     def get_actions(self, request):
         action_dct = super(MergeActionAdmin, self).get_actions(request)
-        action_dct["merge_selected"] = (self.admin_merge, "merge_selected",
-                                        _("Merge selected items"))
+        action_dct["merge_selected"] = (
+            self.admin_merge,
+            "merge_selected",
+            _("Merge selected items"),
+        )
         return action_dct
 
     def admin_merge(self, modeladmin, request, queryset):
         return_url = reverse(
-            'admin:%s_%s_changelist' % (
-                self.model._meta.app_label,
-                self.model._meta.model_name)
+            "admin:%s_%s_changelist"
+            % (self.model._meta.app_label, self.model._meta.model_name)
         )
         if not request.POST:
             return HttpResponseRedirect(return_url)
 
-        selected = request.POST.getlist('_selected_action', [])
+        selected = request.POST.getlist("_selected_action", [])
         if len(selected) < 2:
             messages.add_message(
-                request, messages.WARNING,
-                str(_("At least two items have to be selected."))
+                request,
+                messages.WARNING,
+                str(_("At least two items have to be selected.")),
             )
             return HttpResponseRedirect(return_url)
 
@@ -292,10 +321,10 @@ class MergeActionAdmin:
             items[str(obj.pk)] = obj
 
         form = None
-        if 'apply' in request.POST:
+        if "apply" in request.POST:
             form = MergeForm(choices, request.POST, request.FILES)
             if form.is_valid():
-                merge_in = items[form.cleaned_data['merge_in']]
+                merge_in = items[form.cleaned_data["merge_in"]]
                 merged = []
                 for key, value in items.items():
                     if key == str(merge_in.pk):
@@ -303,30 +332,40 @@ class MergeActionAdmin:
                     merge_model_objects(merge_in, value)
                     merged.append(str(value))
                 messages.add_message(
-                    request, messages.INFO,
-                    str(_("{} merged into {}.")).format(' ; '.join(merged),
-                                                        str(merge_in))
+                    request,
+                    messages.INFO,
+                    str(_("{} merged into {}.")).format(
+                        " ; ".join(merged), str(merge_in)
+                    ),
                 )
                 return HttpResponseRedirect(return_url)
         if not form:
             form = MergeForm(choices)
         return render(
-            request, 'admin/merge.html',
-            {'merge_form': form, 'current_action': 'merge_selected',
-             'selected_items': selected}
+            request,
+            "admin/merge.html",
+            {
+                "merge_form": form,
+                "current_action": "merge_selected",
+                "selected_items": selected,
+            },
         )
 
 
-TokenAdmin.raw_id_fields = ('user',)
+TokenAdmin.raw_id_fields = ("user",)
 admin_site.register(Token, TokenAdmin)
 
 
 class HistorizedObjectAdmin(admin.ModelAdmin):
-    readonly_fields = ['history_creator', 'history_modifier', 'search_vector',
-                       'history_m2m']
+    readonly_fields = [
+        "history_creator",
+        "history_modifier",
+        "search_vector",
+        "history_m2m",
+    ]
 
     AJAX_FORM_DICT = {
-        'lock_user': 'user',
+        "lock_user": "user",
     }
 
     def save_model(self, request, obj, form, change):
@@ -335,20 +374,18 @@ class HistorizedObjectAdmin(admin.ModelAdmin):
 
     def get_readonly_fields(self, request, obj=None):
         if obj:  # editing an existing object
-            return tuple(self.readonly_fields or []) + tuple(['imports'])
+            return tuple(self.readonly_fields or []) + tuple(["imports"])
         return self.readonly_fields
 
     def get_exclude(self, request, obj=None):
         if not obj:
-            return tuple(self.exclude or []) + tuple(['imports'])
+            return tuple(self.exclude or []) + tuple(["imports"])
         return self.exclude
 
 
 class MyGroupAdmin(GroupAdmin):
     class Media:
-        css = {
-            "all": ("media/admin.css",)
-        }
+        css = {"all": ("media/admin.css",)}
 
 
 admin_site.register(User, UserAdmin)
@@ -360,13 +397,22 @@ class AdminIshtarSiteProfileForm(forms.ModelForm):
     class Meta:
         model = models.IshtarSiteProfile
         exclude = []
-    default_center = PointField(label=_("Maps - default center"),
-                                widget=OSMWidget)
+
+    default_center = PointField(label=_("Maps - default center"), widget=OSMWidget)
 
 
 class IshtarSiteProfileAdmin(admin.ModelAdmin):
-    list_display = ('label', 'slug', 'active', 'files', 'context_record',
-                    'find', 'warehouse', 'mapping', 'preservation')
+    list_display = (
+        "label",
+        "slug",
+        "active",
+        "files",
+        "context_record",
+        "find",
+        "warehouse",
+        "mapping",
+        "preservation",
+    )
     model = models.IshtarSiteProfile
     form = AdminIshtarSiteProfileForm
 
@@ -375,7 +421,10 @@ admin_site.register(models.IshtarSiteProfile, IshtarSiteProfileAdmin)
 
 
 class DepartmentAdmin(admin.ModelAdmin):
-    list_display = ('number', 'label',)
+    list_display = (
+        "number",
+        "label",
+    )
     model = models_common.Department
 
 
@@ -383,14 +432,16 @@ admin_site.register(models_common.Department, DepartmentAdmin)
 
 
 class OrganizationAdmin(HistorizedObjectAdmin):
-    list_display = ('pk', 'name', 'organization_type')
+    list_display = ("pk", "name", "organization_type")
     list_filter = ("organization_type",)
-    search_fields = ('name',)
-    exclude = ('merge_key', 'merge_exclusion', 'merge_candidate', )
-    model = models.Organization
-    form = make_ajax_form(
-        model, {'precise_town': 'town'}
+    search_fields = ("name",)
+    exclude = (
+        "merge_key",
+        "merge_exclusion",
+        "merge_candidate",
     )
+    model = models.Organization
+    form = make_ajax_form(model, {"precise_town": "town"})
 
 
 admin_site.register(models.Organization, OrganizationAdmin)
@@ -404,11 +455,15 @@ class ProfileInline(admin.TabularInline):
 
 
 class PersonAdmin(HistorizedObjectAdmin):
-    list_display = ('pk', 'name', 'surname', 'raw_name', 'email')
+    list_display = ("pk", "name", "surname", "raw_name", "email")
     list_filter = ("person_types",)
-    search_fields = ('name', 'surname', 'email', 'raw_name')
-    exclude = ('merge_key', 'merge_exclusion', 'merge_candidate', )
-    form = make_ajax_form(models.Person, {'attached_to': 'organization'})
+    search_fields = ("name", "surname", "email", "raw_name")
+    exclude = (
+        "merge_key",
+        "merge_exclusion",
+        "merge_candidate",
+    )
+    form = make_ajax_form(models.Person, {"attached_to": "organization"})
     model = models.Person
     inlines = [ProfileInline]
 
@@ -417,19 +472,18 @@ admin_site.register(models.Person, PersonAdmin)
 
 
 class AuthorAdmin(admin.ModelAdmin):
-    list_display = ['person', 'author_type']
+    list_display = ["person", "author_type"]
     list_filter = ("author_type",)
-    search_fields = ('person__name', 'person__surname',
-                     'person__attached_to__name')
+    search_fields = ("person__name", "person__surname", "person__attached_to__name")
     model = models.Author
-    form = make_ajax_form(models.Author, {'person': 'person'})
+    form = make_ajax_form(models.Author, {"person": "person"})
 
 
 admin_site.register(models.Author, AuthorAdmin)
 
 
 class GlobalVarAdmin(admin.ModelAdmin):
-    list_display = ['slug', 'description', 'value']
+    list_display = ["slug", "description", "value"]
 
 
 admin_site.register(models.GlobalVar, GlobalVarAdmin)
@@ -441,12 +495,10 @@ class ChangeListForChangeView(ChangeList):
         Get the current list queryset parameters from _changelist_filters
         """
         filtered_params = {}
-        lookup_params = super(
-            ChangeListForChangeView, self).get_filters_params(params)
-        if '_changelist_filters' in lookup_params:
-            field_names = [field.name for field in
-                           self.model._meta.get_fields()]
-            params = lookup_params.pop('_changelist_filters')
+        lookup_params = super(ChangeListForChangeView, self).get_filters_params(params)
+        if "_changelist_filters" in lookup_params:
+            field_names = [field.name for field in self.model._meta.get_fields()]
+            params = lookup_params.pop("_changelist_filters")
             for param in params.split("&"):
                 key, value = param.split("=")
                 if not value or key not in field_names:
@@ -457,24 +509,25 @@ class ChangeListForChangeView(ChangeList):
 
 class ImportActionAdmin(admin.ModelAdmin):
     change_list_template = "admin/gen_change_list.html"
-    import_keys = ['slug', 'txt_idx']
+    import_keys = ["slug", "txt_idx"]
 
     def get_urls(self):
         urls = super(ImportActionAdmin, self).get_urls()
         my_urls = [
-            url(r'^import-from-csv/$', self.import_generic),
+            url(r"^import-from-csv/$", self.import_generic),
         ]
         return my_urls + urls
 
     def import_generic(self, request):
         form = None
 
-        if 'apply' in request.POST:
+        if "apply" in request.POST:
             form = ImportGenericForm(request.POST, request.FILES)
             if form.is_valid():
-                encoding = request.encoding or 'utf-8'
-                csv_file = TextIOWrapper(request.FILES['csv_file'].file,
-                                         encoding=encoding)
+                encoding = request.encoding or "utf-8"
+                csv_file = TextIOWrapper(
+                    request.FILES["csv_file"].file, encoding=encoding
+                )
                 reader = csv.DictReader(csv_file)
                 created, updated, missing_parent = 0, 0, []
                 for row in reader:
@@ -486,19 +539,20 @@ class ImportActionAdmin(admin.ModelAdmin):
                     if not slug_col:
                         self.message_user(
                             request,
-                            str(_("The CSV file should at least have a "
-                                  "{} column")).format(
-                                "/".join(self.import_keys)))
+                            str(
+                                _("The CSV file should at least have a " "{} column")
+                            ).format("/".join(self.import_keys)),
+                        )
                         return
                     slug = row.pop(slug_col)
-                    if 'id' in row:
-                        row.pop('id')
-                    if 'pk' in row:
-                        row.pop('pk')
+                    if "id" in row:
+                        row.pop("id")
+                    if "pk" in row:
+                        row.pop("pk")
                     for k in list(row.keys()):
                         value = row[k]
-                        if value == 'None':
-                            value = ''
+                        if value == "None":
+                            value = ""
                         try:
                             field = self.model._meta.get_field(k)
                         except FieldDoesNotExist:
@@ -512,9 +566,9 @@ class ImportActionAdmin(admin.ModelAdmin):
                         elif isinstance(field, FloatField):
                             value = None if not value else float(value)
                         elif isinstance(field, BooleanField):
-                            if value in ('true', 'True', '1'):
+                            if value in ("true", "True", "1"):
                                 value = True
-                            elif value in ('false', 'False', '0'):
+                            elif value in ("false", "False", "0"):
                                 value = False
                             else:
                                 value = None
@@ -522,80 +576,79 @@ class ImportActionAdmin(admin.ModelAdmin):
                             if value:
                                 model = field.rel.to
                                 try:
-                                    value = model.objects.get(
-                                        **{slug_col: value}
-                                    )
+                                    value = model.objects.get(**{slug_col: value})
                                 except model.DoesNotExist:
                                     missing_parent.append(row.pop(k))
                                     continue
                             else:
                                 value = None
                         row[k] = value
-                    values = {
-                        slug_col: slug,
-                        'defaults': row
-                    }
-                    obj, c = self.model.objects.get_or_create(
-                        **values)
+                    values = {slug_col: slug, "defaults": row}
+                    obj, c = self.model.objects.get_or_create(**values)
                     if c:
                         created += 1
                     else:
                         updated += 1
                         self.model.objects.filter(pk=obj.pk).update(**row)
                 if created:
-                    self.message_user(
-                        request,
-                        str(_("%d item(s) created.")) % created)
+                    self.message_user(request, str(_("%d item(s) created.")) % created)
                 if updated:
-                    self.message_user(
-                        request,
-                        str(_("%d item(s) updated.")) % updated)
+                    self.message_user(request, str(_("%d item(s) updated.")) % updated)
                 if missing_parent:
                     self.message_user(
                         request,
                         str(_("These parents are missing: {}")).format(
-                            " ; ".join(missing_parent)))
+                            " ; ".join(missing_parent)
+                        ),
+                    )
                 url = reverse(
-                    'admin:%s_%s_changelist' % (
-                        self.model._meta.app_label, self.model._meta.model_name)
+                    "admin:%s_%s_changelist"
+                    % (self.model._meta.app_label, self.model._meta.model_name)
                 )
                 return HttpResponseRedirect(url)
         if not form:
             form = ImportGenericForm()
         return render(
-            request, 'admin/import_from_file.html',
-            {'file_form': form, 'current_action': 'import_generic'}
+            request,
+            "admin/import_from_file.html",
+            {"file_form": form, "current_action": "import_generic"},
         )
 
 
 class ImportGeoJsonForm(forms.Form):
     json_file = forms.FileField(
         _("Geojson file"),
-        help_text=_("Only unicode encoding is managed - convert your"
-                    " file first. The file must be a geojson file or a zip "
-                    "containing a geojson file.")
+        help_text=_(
+            "Only unicode encoding is managed - convert your"
+            " file first. The file must be a geojson file or a zip "
+            "containing a geojson file."
+        ),
     )
     numero_insee_prefix = forms.CharField(
-        label=_("Prefix for numero INSEE"), max_length=20, required=False)
+        label=_("Prefix for numero INSEE"), max_length=20, required=False
+    )
     numero_insee_name = forms.CharField(
-        label=_("Field name for numero INSEE"), max_length=200,
-        initial='numero_insee')
+        label=_("Field name for numero INSEE"), max_length=200, initial="numero_insee"
+    )
     name_name = forms.CharField(
-        label=_("Field name for name"), max_length=200, initial='name')
-    UNIT_CHOICES = (('1', _("m2")), ('1000', _("km2")))
-    surface_unit = forms.ChoiceField(
-        label=_("Surface unit"), choices=UNIT_CHOICES)
+        label=_("Field name for name"), max_length=200, initial="name"
+    )
+    UNIT_CHOICES = (("1", _("m2")), ("1000", _("km2")))
+    surface_unit = forms.ChoiceField(label=_("Surface unit"), choices=UNIT_CHOICES)
     surface_name = forms.CharField(
-        label=_("Field name for surface"), max_length=200, required=False)
+        label=_("Field name for surface"), max_length=200, required=False
+    )
     year_name = forms.CharField(
-        label=_("Field name for year"), max_length=200, required=False,
+        label=_("Field name for year"),
+        max_length=200,
+        required=False,
         initial="year",
-        help_text=_("Not required for new town. Leave it empty when not "
-                    "available.")
+        help_text=_("Not required for new town. Leave it empty when not " "available."),
     )
     update = forms.BooleanField(
-        label=_("Update only geometry of existing towns"), required=False,
-        widget=forms.CheckboxInput
+        label=_("Update only geometry of existing towns"),
+        required=False,
+        widget=forms.CheckboxInput,
     )
 
 
@@ -603,7 +656,7 @@ class ImportGEOJSONActionAdmin(object):
     def get_urls(self):
         urls = super(ImportGEOJSONActionAdmin, self).get_urls()
         my_urls = [
-            url(r'^import-from-geojson/$', self.import_geojson),
+            url(r"^import-from-geojson/$", self.import_geojson),
         ]
         return my_urls + urls
 
@@ -612,66 +665,57 @@ class ImportGEOJSONActionAdmin(object):
             if key in feature:
                 continue
             if trace_error:
-                error = str(
-                    _("\"{}\" not found in feature {}")
-                ).format(key, idx)
+                error = str(_('"{}" not found in feature {}')).format(key, idx)
                 self.message_user(request, error, level=messages.ERROR)
             return False
 
         values = {}
         for key in keys:
-            if not key.endswith('_name'):
+            if not key.endswith("_name"):
                 continue
             if not keys[key]:
-                values[key[:-len("_name")]] = None
+                values[key[: -len("_name")]] = None
                 continue
-            if keys[key] not in feature['properties']:
+            if keys[key] not in feature["properties"]:
                 if trace_error:
-                    error = str(
-                        _("\"{}\" not found in properties of feature {}")
-                    ).format(keys[key], idx)
-                    self.message_user(request, error,
-                                      level=messages.ERROR)
+                    error = str(_('"{}" not found in properties of feature {}')).format(
+                        keys[key], idx
+                    )
+                    self.message_user(request, error, level=messages.ERROR)
                 return False
-            value = feature['properties'][keys[key]]
-            if key == 'numero_insee_name' and keys['insee_prefix']:
-                value = keys['insee_prefix'] + value
-            values[key[:-len("_name")]] = value
+            value = feature["properties"][keys[key]]
+            if key == "numero_insee_name" and keys["insee_prefix"]:
+                value = keys["insee_prefix"] + value
+            values[key[: -len("_name")]] = value
         try:
-            geom = GEOSGeometry(json.dumps(feature['geometry']))
+            geom = GEOSGeometry(json.dumps(feature["geometry"]))
         except (GEOSException, GDALException):
             if trace_error:
-                error = str(
-                    _("Bad geometry for feature {}")
-                ).format(idx)
-                self.message_user(request, error,
-                                  level=messages.ERROR)
+                error = str(_("Bad geometry for feature {}")).format(idx)
+                self.message_user(request, error, level=messages.ERROR)
             return False
-        if geom.geom_type == 'Point':
-            values['center'] = geom
-        elif geom.geom_type == 'MultiPolygon':
-            values['limit'] = geom
-        elif geom.geom_type == 'Polygon':
-            values['limit'] = MultiPolygon(geom)
+        if geom.geom_type == "Point":
+            values["center"] = geom
+        elif geom.geom_type == "MultiPolygon":
+            values["limit"] = geom
+        elif geom.geom_type == "Polygon":
+            values["limit"] = MultiPolygon(geom)
         else:
             if trace_error:
-                error = str(
-                    _("Geometry {} not managed for towns - feature {}")
-                ).format(geom.geom_type, idx)
-                self.message_user(request, error,
-                                  level=messages.ERROR)
+                error = str(_("Geometry {} not managed for towns - feature {}")).format(
+                    geom.geom_type, idx
+                )
+                self.message_user(request, error, level=messages.ERROR)
             return False
-        if keys['surface_unit'] and values['surface']:
+        if keys["surface_unit"] and values["surface"]:
             try:
-                values['surface'] = keys['surface_unit'] * int(
-                    values['surface'])
+                values["surface"] = keys["surface_unit"] * int(values["surface"])
             except ValueError:
                 if trace_error:
-                    error = str(
-                        _("Bad value for surface: {} - feature {}")
-                    ).format(values['surface'], idx)
-                    self.message_user(request, error,
-                                      level=messages.ERROR)
+                    error = str(_("Bad value for surface: {} - feature {}")).format(
+                        values["surface"], idx
+                    )
+                    self.message_user(request, error, level=messages.ERROR)
                 return False
 
         return values
@@ -684,24 +728,21 @@ class ImportGEOJSONActionAdmin(object):
     def import_geojson_error(self, request, error, base_dct, tempdir=None):
         self.import_geojson_clean(tempdir)
         self.message_user(request, error, level=messages.ERROR)
-        return render(
-            request, 'admin/import_from_file.html',
-            base_dct)
+        return render(request, "admin/import_from_file.html", base_dct)
 
     def import_geojson(self, request):
         form = None
 
-        if 'apply' in request.POST:
+        if "apply" in request.POST:
             form = ImportGeoJsonForm(request.POST, request.FILES)
             if form.is_valid():
-                json_file_obj = request.FILES['json_file']
+                json_file_obj = request.FILES["json_file"]
 
-                base_dct = {'file_form': form,
-                            'current_action': 'import_geojson'}
+                base_dct = {"file_form": form, "current_action": "import_geojson"}
 
                 tempdir = tempfile.mkdtemp()
                 tmpfilename = tempdir + os.sep + "dest_file"
-                with open(tmpfilename, 'wb+') as tmpfile:
+                with open(tmpfilename, "wb+") as tmpfile:
                     for chunk in json_file_obj.chunks():
                         tmpfile.write(chunk)
                 json_filename = None
@@ -716,40 +757,42 @@ class ImportGEOJSONActionAdmin(object):
                             break
                     if not json_filename:
                         error = _("No json file found in zipfile")
-                        return self.import_geojson_error(request, error,
-                                                         base_dct, tempdir)
+                        return self.import_geojson_error(
+                            request, error, base_dct, tempdir
+                        )
                 else:
                     json_filename = tmpfilename
 
                 keys = {
-                    "numero_insee_name": request.POST.get('numero_insee_name'),
-                    "name_name": request.POST.get('name_name'),
-                    "surface_name": request.POST.get('surface_name', "") or "",
-                    "year_name": request.POST.get('year_name', "") or "",
-                    "update": request.POST.get('update', "") or "",
-                    "insee_prefix": request.POST.get('numero_insee_prefix',
-                                                     None) or '',
-                    "surface_unit": int(request.POST.get('surface_unit'))
+                    "numero_insee_name": request.POST.get("numero_insee_name"),
+                    "name_name": request.POST.get("name_name"),
+                    "surface_name": request.POST.get("surface_name", "") or "",
+                    "year_name": request.POST.get("year_name", "") or "",
+                    "update": request.POST.get("update", "") or "",
+                    "insee_prefix": request.POST.get("numero_insee_prefix", None) or "",
+                    "surface_unit": int(request.POST.get("surface_unit")),
                 }
                 with open(json_filename) as json_file_obj:
                     json_file = json_file_obj.read()
                     try:
                         dct = json.loads(json_file)
-                        assert 'features' in dct
-                        assert dct['features']
+                        assert "features" in dct
+                        assert dct["features"]
                     except (ValueError, AssertionError):
                         error = _("Bad geojson file")
                         return self.import_geojson_error(
-                            request, error, base_dct, tempdir)
+                            request, error, base_dct, tempdir
+                        )
 
                     error_count = 0
                     created = 0
                     updated = 0
-                    for idx, feat in enumerate(dct['features']):
+                    for idx, feat in enumerate(dct["features"]):
                         trace_error = True
                         if error_count == 6:
-                            self.message_user(request, _("Too many errors..."),
-                                              level=messages.ERROR)
+                            self.message_user(
+                                request, _("Too many errors..."), level=messages.ERROR
+                            )
                         if error_count > 5:
                             trace_error = False
                         values = self.geojson_values(
@@ -758,18 +801,17 @@ class ImportGEOJSONActionAdmin(object):
                         if not values:
                             error_count += 1
                             continue
-                        num_insee = values.pop('numero_insee')
-                        year = values.pop('year') or None
+                        num_insee = values.pop("numero_insee")
+                        year = values.pop("year") or None
                         t, c = models_common.Town.objects.get_or_create(
-                            numero_insee=num_insee, year=year,
-                            defaults=values)
+                            numero_insee=num_insee, year=year, defaults=values
+                        )
                         if c:
                             created += 1
                         else:
                             modified = False
                             for k in values:
-                                if keys['update'] and k not in ["center",
-                                                                "limit"]:
+                                if keys["update"] and k not in ["center", "limit"]:
                                     continue
                                 if values[k] != getattr(t, k):
                                     setattr(t, k, values[k])
@@ -779,78 +821,81 @@ class ImportGEOJSONActionAdmin(object):
                                 t.save()
                     if created:
                         self.message_user(
-                            request,
-                            str(_("%d item(s) created.")) % created)
+                            request, str(_("%d item(s) created.")) % created
+                        )
                     if updated:
                         self.message_user(
-                            request,
-                            str(_("%d item(s) updated.")) % updated)
+                            request, str(_("%d item(s) updated.")) % updated
+                        )
                     self.import_geojson_clean(tempdir)
                     url = reverse(
-                        'admin:%s_%s_changelist' % (
-                            self.model._meta.app_label,
-                            self.model._meta.model_name)
+                        "admin:%s_%s_changelist"
+                        % (self.model._meta.app_label, self.model._meta.model_name)
                     )
                     return HttpResponseRedirect(url)
         if not form:
             form = ImportGeoJsonForm()
         return render(
-            request, 'admin/import_from_file.html',
-            {'file_form': form, 'current_action': 'import_geojson'})
+            request,
+            "admin/import_from_file.html",
+            {"file_form": form, "current_action": "import_geojson"},
+        )
 
 
 class ImportJSONForm(forms.Form):
     json_file = forms.FileField(
         _("Zipped JSON file"),
-        help_text=_("Import from a zipped JSON file generated by Ishtar")
+        help_text=_("Import from a zipped JSON file generated by Ishtar"),
     )
 
 
 class ImportJSONActionAdmin(admin.ModelAdmin):
     change_list_template = "admin/json_change_list.html"
-    import_keys = ['slug', 'txt_idx']
+    import_keys = ["slug", "txt_idx"]
 
     def get_urls(self):
         urls = super(ImportJSONActionAdmin, self).get_urls()
         my_urls = [
-            url(r'^import-from-json/$', self.import_json),
+            url(r"^import-from-json/$", self.import_json),
         ]
         return my_urls + urls
 
     def import_json(self, request):
         form = None
 
-        if 'apply' in request.POST:
+        if "apply" in request.POST:
             form = ImportJSONForm(request.POST, request.FILES)
             if form.is_valid():
                 with tempfile.TemporaryDirectory() as tmpdirname:
                     filename = tmpdirname + os.sep + "export.zip"
                     with open(filename, "wb+") as zipped_file:
-                        for chunk in request.FILES['json_file'].chunks():
+                        for chunk in request.FILES["json_file"].chunks():
                             zipped_file.write(chunk)
                     result = None
                     result = restore_serialized(filename)
                     try:
                         result = restore_serialized(filename)
                     except ValueError as e:
-                        self.message_user(request, str(e),
-                                          level=messages.ERROR)
+                        self.message_user(request, str(e), level=messages.ERROR)
                     if result:
                         for model, count in result:
                             self.message_user(
                                 request,
                                 str(_("{} {}(s) created/updated.")).format(
-                                    count, model))
+                                    count, model
+                                ),
+                            )
                 url = reverse(
-                    'admin:%s_%s_changelist' % (
-                        self.model._meta.app_label, self.model._meta.model_name)
+                    "admin:%s_%s_changelist"
+                    % (self.model._meta.app_label, self.model._meta.model_name)
                 )
                 return HttpResponseRedirect(url)
         if not form:
             form = ImportJSONForm()
         return render(
-            request, 'admin/import_from_file.html',
-            {'file_form': form, 'current_action': 'import_json'}
+            request,
+            "admin/import_from_file.html",
+            {"file_form": form, "current_action": "import_json"},
         )
 
 
@@ -858,25 +903,25 @@ class AdminRelatedTownForm(forms.ModelForm):
     class Meta:
         model = models_common.Town.children.through
         exclude = []
-    from_town = AutoCompleteSelectField(
-        'town', required=True, label=_("Parent"))
+
+    from_town = AutoCompleteSelectField("town", required=True, label=_("Parent"))
 
 
 class AdminTownForm(forms.ModelForm):
     class Meta:
         model = models_common.Town
-        exclude = ['imports', 'departement']
-    center = PointField(label=_("Center"), required=False,
-                        widget=OSMWidget)
-    limit = MultiPolygonField(label=_("Limit"), required=False,
-                              widget=OSMWidget)
-    children = AutoCompleteSelectMultipleField('town', required=False,
-                                               label=_("Town children"))
+        exclude = ["imports", "departement"]
+
+    center = PointField(label=_("Center"), required=False, widget=OSMWidget)
+    limit = MultiPolygonField(label=_("Limit"), required=False, widget=OSMWidget)
+    children = AutoCompleteSelectMultipleField(
+        "town", required=False, label=_("Town children")
+    )
 
 
 class TownParentInline(admin.TabularInline):
     model = models_common.Town.children.through
-    fk_name = 'to_town'
+    fk_name = "to_town"
     form = AdminRelatedTownForm
     verbose_name = _("Parent")
     verbose_name_plural = _("Parents")
@@ -887,31 +932,38 @@ class TownAdmin(ImportGEOJSONActionAdmin, ImportActionAdmin):
     change_list_template = "admin/town_change_list.html"
 
     model = models_common.Town
-    list_display = ['name', 'year']
-    search_fields = ['name']
-    readonly_fields = ['cached_label']
-    if settings.COUNTRY == 'fr':
-        list_display += ['numero_insee']
-        search_fields += ['numero_insee', 'areas__label']
+    list_display = ["name", "year"]
+    search_fields = ["name"]
+    readonly_fields = ["cached_label"]
+    if settings.COUNTRY == "fr":
+        list_display += ["numero_insee"]
+        search_fields += ["numero_insee", "areas__label"]
         list_filter = ("areas",)
     form = AdminTownForm
     inlines = [TownParentInline]
-    actions = [export_as_csv_action(exclude=['center', 'limit']),
-               export_as_geojson_action(
-                   "limit", exclude=["center", "departement", "cached_label"])]
-    import_keys = ['slug', 'txt_idx', 'numero_insee']
+    actions = [
+        export_as_csv_action(exclude=["center", "limit"]),
+        export_as_geojson_action(
+            "limit", exclude=["center", "departement", "cached_label"]
+        ),
+    ]
+    import_keys = ["slug", "txt_idx", "numero_insee"]
 
 
 admin_site.register(models_common.Town, TownAdmin)
 
 
 class GeneralTypeAdmin(ImportActionAdmin, ImportJSONActionAdmin):
-    search_fields = ('label', 'txt_idx', 'comment',)
-    list_filter = ('available',)
+    search_fields = (
+        "label",
+        "txt_idx",
+        "comment",
+    )
+    list_filter = ("available",)
     save_on_top = True
     actions = [export_as_csv_action(), serialize_type_action]
     prepopulated_fields = {"txt_idx": ("label",)}
-    LIST_DISPLAY = ['label', 'txt_idx', 'available', 'comment']
+    LIST_DISPLAY = ["label", "txt_idx", "available", "comment"]
     extra_list_display = []
 
     def get_list_display(self, request):
@@ -935,63 +987,85 @@ class GeneralTypeAdmin(ImportActionAdmin, ImportJSONActionAdmin):
         list_select_related = self.get_list_select_related(request)
 
         cl = ChangeListForChangeView(
-            request, self.model, list_display,
-            list_display_links, list_filter, self.date_hierarchy,
-            search_fields, list_select_related, self.list_per_page,
-            self.list_max_show_all, self.list_editable, self,
+            request,
+            self.model,
+            list_display,
+            list_display_links,
+            list_filter,
+            self.date_hierarchy,
+            search_fields,
+            list_select_related,
+            self.list_per_page,
+            self.list_max_show_all,
+            self.list_editable,
+            self,
         )
         return cl.get_queryset(request)
 
-    def change_view(self, request, object_id, form_url='', extra_context=None):
+    def change_view(self, request, object_id, form_url="", extra_context=None):
         """
         Next and previous button on the change view
         """
         if not extra_context:
             extra_context = {}
-        ids = list(self.get_changelist_queryset(request).values('pk'))
+        ids = list(self.get_changelist_queryset(request).values("pk"))
         previous, current_is_reached, first = None, False, None
-        extra_context['get_attr'] = ""
+        extra_context["get_attr"] = ""
         if request.GET:
-            extra_context['get_attr'] = "?" + request.GET.urlencode()
+            extra_context["get_attr"] = "?" + request.GET.urlencode()
         for v in ids:
-            pk = str(v['pk'])
+            pk = str(v["pk"])
             if pk == object_id:
                 current_is_reached = True
                 if previous:
-                    extra_context['previous_item'] = previous
+                    extra_context["previous_item"] = previous
             elif current_is_reached:
-                extra_context['next_item'] = pk
+                extra_context["next_item"] = pk
                 break
             else:
                 if not first:
                     first = pk
                 previous = pk
-        if 'previous_item' not in extra_context and \
-                'next_item' not in extra_context and first:
+        if (
+            "previous_item" not in extra_context
+            and "next_item" not in extra_context
+            and first
+        ):
             # on modify current object do not match current criteria
             # next is the first item
-            extra_context['next_item'] = first
+            extra_context["next_item"] = first
 
         return super(GeneralTypeAdmin, self).change_view(
-            request, object_id, form_url, extra_context)
+            request, object_id, form_url, extra_context
+        )
 
 
-general_models = [models.SourceType, models.AuthorType, models.LicenseType,
-                  models.Language, models.PersonType]
+general_models = [
+    models.SourceType,
+    models.AuthorType,
+    models.LicenseType,
+    models.Language,
+    models.PersonType,
+]
 for model in general_models:
     admin_site.register(model, GeneralTypeAdmin)
 
 
 @admin.register(models.OrganizationType, site=admin_site)
 class PersonTypeAdmin(GeneralTypeAdmin):
-    LIST_DISPLAY = ['label', 'grammatical_gender', 'txt_idx', 'available',
-                    'comment']
+    LIST_DISPLAY = ["label", "grammatical_gender", "txt_idx", "available", "comment"]
 
 
 @admin.register(models.TitleType, site=admin_site)
 class TitleType(GeneralTypeAdmin):
-    LIST_DISPLAY = ['label', 'long_title', 'grammatical_gender', 'txt_idx',
-                    'available', 'comment']
+    LIST_DISPLAY = [
+        "label",
+        "long_title",
+        "grammatical_gender",
+        "txt_idx",
+        "available",
+        "comment",
+    ]
 
 
 class CreateAreaForm(forms.Form):
@@ -1001,31 +1075,33 @@ class CreateAreaForm(forms.Form):
 
     def __init__(self, *args, **kwargs):
         super(CreateAreaForm, self).__init__(*args, **kwargs)
-        self.fields["area"].choices = [('', '--')] + [
-            (area.pk, area.label)
-            for area in models.Area.objects.order_by("reference")]
+        self.fields["area"].choices = [("", "--")] + [
+            (area.pk, area.label) for area in models.Area.objects.order_by("reference")
+        ]
 
     def clean(self):
-        area_name = self.cleaned_data.get('area_name', "")
-        area = self.cleaned_data.get('area', 0)
+        area_name = self.cleaned_data.get("area_name", "")
+        area = self.cleaned_data.get("area", 0)
         if (not area_name and not area) or (area and area_name):
-            raise forms.ValidationError(_("Choose an area or set an area "
-                                          "reference."))
+            raise forms.ValidationError(
+                _("Choose an area or set an area " "reference.")
+            )
         return self.cleaned_data
 
     def clean_department_number(self):
-        value = self.cleaned_data.get('department_number', 0)
+        value = self.cleaned_data.get("department_number", 0)
         if value < 1 or (value > 95 and (value < 970 or value > 989)):
             raise forms.ValidationError(_("Invalid department number."))
         return value
 
     def clean_area_name(self):
-        value = self.cleaned_data.get('area_name', '')
+        value = self.cleaned_data.get("area_name", "")
         if not value:
             return value
         if models.Area.objects.filter(label=value).count():
-            raise forms.ValidationError(_("This name is already used by "
-                                          "another area."))
+            raise forms.ValidationError(
+                _("This name is already used by " "another area.")
+            )
         return value
 
 
@@ -1035,64 +1111,68 @@ class CreateDepartmentActionAdmin(GeneralTypeAdmin):
     def get_urls(self):
         urls = super(CreateDepartmentActionAdmin, self).get_urls()
         my_urls = [
-            url(r'^create-department/$', self.create_area),
+            url(r"^create-department/$", self.create_area),
         ]
         return my_urls + urls
 
     def create_area(self, request):
         form = None
 
-        if 'apply' in request.POST:
+        if "apply" in request.POST:
             form = CreateAreaForm(request.POST)
             if form.is_valid():
-                area_name = form.cleaned_data.get("area_name", '')
+                area_name = form.cleaned_data.get("area_name", "")
                 if area_name:
                     slug = "dpt-" + area_name
                     while models.Area.objects.filter(txt_idx=slug).count():
                         slug += "b"
-                    area = models.Area.objects.create(label=area_name,
-                                                      txt_idx=slug)
+                    area = models.Area.objects.create(label=area_name, txt_idx=slug)
                     self.message_user(
-                        request,
-                        str(_('Area "{}" created.')).format(area_name))
+                        request, str(_('Area "{}" created.')).format(area_name)
+                    )
                 else:
-                    area = models.Area.objects.get(
-                        id=form.cleaned_data["area"])
-                dpt_num = form.cleaned_data['department_number']
+                    area = models.Area.objects.get(id=form.cleaned_data["area"])
+                dpt_num = form.cleaned_data["department_number"]
                 dpt_num = "0" + str(dpt_num) if dpt_num < 10 else str(dpt_num)
                 current_towns = [a.numero_insee for a in area.towns.all()]
                 nb = 0
-                for town in models.Town.objects.filter(
-                        numero_insee__startswith=dpt_num).exclude(
-                            numero_insee__in=current_towns).all():
+                for town in (
+                    models.Town.objects.filter(numero_insee__startswith=dpt_num)
+                    .exclude(numero_insee__in=current_towns)
+                    .all()
+                ):
                     area.towns.add(town)
                     nb += 1
                 self.message_user(
                     request,
                     str(_('{} town(s) added to "{}".')).format(
-                        nb, area_name or area.label))
+                        nb, area_name or area.label
+                    ),
+                )
                 url = reverse(
-                    'admin:%s_%s_changelist' % (
-                        self.model._meta.app_label, self.model._meta.model_name)
+                    "admin:%s_%s_changelist"
+                    % (self.model._meta.app_label, self.model._meta.model_name)
                 )
                 return HttpResponseRedirect(url)
         if not form:
             form = CreateAreaForm()
         return render(
-            request, 'admin/create_area_dpt.html',
-            {'form': form, 'current_action': 'create_area'}
+            request,
+            "admin/create_area_dpt.html",
+            {"form": form, "current_action": "create_area"},
         )
 
+
 @admin.register(models.SupportType, site=admin_site)
 class SupportType(GeneralTypeAdmin):
     model = models.SupportType
-    form = make_ajax_form(model, {'document_types': 'source_type'})
+    form = make_ajax_form(model, {"document_types": "source_type"})
 
 
 @admin.register(models.Format, site=admin_site)
 class Format(GeneralTypeAdmin):
     model = models.Format
-    form = make_ajax_form(model, {'document_types': 'source_type'})
+    form = make_ajax_form(model, {"document_types": "source_type"})
 
 
 @admin.register(models.DocumentTag, site=admin_site)
@@ -1101,29 +1181,28 @@ class DocumentTag(MergeActionAdmin, GeneralTypeAdmin):
 
 
 class AreaAdmin(CreateDepartmentActionAdmin):
-    list_display = ('label', 'reference', 'parent', 'available')
-    search_fields = ('label', 'reference')
-    list_filter = ('parent',)
+    list_display = ("label", "reference", "parent", "available")
+    search_fields = ("label", "reference")
+    list_filter = ("parent",)
     model = models.Area
-    form = make_ajax_form(
-        model, {'towns': 'town'}
-    )
+    form = make_ajax_form(model, {"towns": "town"})
+
 
 admin_site.register(models.Area, AreaAdmin)
 
 
 class ProfileTypeAdmin(GeneralTypeAdmin):
     model = models.ProfileType
-    filter_vertical = ('groups',)
+    filter_vertical = ("groups",)
 
 
 admin_site.register(models.ProfileType, ProfileTypeAdmin)
 
 
 class ProfileTypeSummaryAdmin(admin.ModelAdmin):
-    change_list_template = 'admin/profiletype_summary_change_list.html'
-    search_fields = ('label',)
-    list_filter = ('available', 'label')
+    change_list_template = "admin/profiletype_summary_change_list.html"
+    search_fields = ("label",)
+    list_filter = ("available", "label")
 
     def has_add_permission(self, request, obj=None):
         return False
@@ -1139,9 +1218,7 @@ class ProfileTypeSummaryAdmin(admin.ModelAdmin):
         except (AttributeError, KeyError):
             return response
 
-        profile_types = list(
-            qs.order_by("label")
-        )
+        profile_types = list(qs.order_by("label"))
         rights = {
             profile_type.pk: [g.pk for g in profile_type.groups.all()]
             for profile_type in profile_types
@@ -1151,17 +1228,15 @@ class ProfileTypeSummaryAdmin(admin.ModelAdmin):
         ok = mark_safe(
             '<img src="{}admin/img/icon-yes.svg" alt="True">'.format(
                 settings.STATIC_URL
-            ))
+            )
+        )
         for group in models.Group.objects.order_by("name"):
             gp = [group.name]
             for profile_type in profile_types:
-                gp.append(
-                    ok if group.pk in rights[profile_type.pk]
-                    else "-")
+                gp.append(ok if group.pk in rights[profile_type.pk] else "-")
             groups.append(gp)
 
-        response.context_data.update({"profile_types": profile_types,
-                                      "groups": groups})
+        response.context_data.update({"profile_types": profile_types, "groups": groups})
         return response
 
 
@@ -1173,7 +1248,7 @@ class ImporterDefaultValuesInline(admin.TabularInline):
 
 
 class ImporterDefaultAdmin(admin.ModelAdmin):
-    list_display = ('importer_type', 'target')
+    list_display = ("importer_type", "target")
     model = models.ImporterDefault
     inlines = (ImporterDefaultValuesInline,)
 
@@ -1183,7 +1258,7 @@ admin_site.register(models.ImporterDefault, ImporterDefaultAdmin)
 
 def duplicate_importertype(modeladmin, request, queryset):
     res = []
-    for obj in queryset.order_by('pk'):
+    for obj in queryset.order_by("pk"):
         old_pk = obj.pk
         obj.pk = None
         obj.slug = create_slug(models.ImporterType, obj.name)
@@ -1224,15 +1299,20 @@ def duplicate_importertype(modeladmin, request, queryset):
                 tg.save()
         res.append(str(obj))
     messages.add_message(
-        request, messages.INFO,
+        request,
+        messages.INFO,
         str(_("{} importer type(s) duplicated: {}.")).format(
-            queryset.count(), " ; ".join(res))
+            queryset.count(), " ; ".join(res)
+        ),
+    )
+    url = (
+        reverse(
+            "admin:%s_%s_changelist"
+            % (modeladmin.model._meta.app_label, modeladmin.model._meta.model_name)
         )
-    url = reverse(
-        'admin:%s_%s_changelist' % (
-            modeladmin.model._meta.app_label,
-            modeladmin.model._meta.model_name)
-    ) + '?' + urllib.parse.urlencode(request.GET)
+        + "?"
+        + urllib.parse.urlencode(request.GET)
+    )
     return HttpResponseRedirect(url)
 
 
@@ -1242,34 +1322,37 @@ duplicate_importertype.short_description = _("Duplicate")
 def generate_libreoffice_template(modeladmin, request, queryset):
     if queryset.count() != 1:
         messages.add_message(
-            request, messages.ERROR,
-            str(_("Select only one importer."))
+            request, messages.ERROR, str(_("Select only one importer."))
+        )
+        url = (
+            reverse(
+                "admin:%s_%s_changelist"
+                % (modeladmin.model._meta.app_label, modeladmin.model._meta.model_name)
+            )
+            + "?"
+            + urllib.parse.urlencode(request.GET)
         )
-        url = reverse(
-            'admin:%s_%s_changelist' % (
-                modeladmin.model._meta.app_label,
-                modeladmin.model._meta.model_name)
-        ) + '?' + urllib.parse.urlencode(request.GET)
         return HttpResponseRedirect(url)
 
     importer_type = queryset.all()[0]
     dest_filename = importer_type.get_libreoffice_template()
     in_memory = BytesIO()
-    with open(dest_filename, 'rb') as fle:
+    with open(dest_filename, "rb") as fle:
         in_memory.write(fle.read())
         filename = dest_filename.split(os.sep)[-1]
 
         response = HttpResponse(
-            content_type='application/vnd.oasis.opendocument.spreadsheet')
-        response['Content-Disposition'] = 'attachment; filename=%s' % \
-                                          filename.replace(' ', '_')
+            content_type="application/vnd.oasis.opendocument.spreadsheet"
+        )
+        response["Content-Disposition"] = "attachment; filename=%s" % filename.replace(
+            " ", "_"
+        )
         in_memory.seek(0)
         response.write(in_memory.read())
         return response
 
 
-generate_libreoffice_template.short_description = \
-    _("Export as libreoffice template")
+generate_libreoffice_template.short_description = _("Export as libreoffice template")
 
 
 importer_type_actions = [duplicate_importertype]
@@ -1277,28 +1360,27 @@ if settings.USE_LIBREOFFICE:
     importer_type_actions.append(generate_libreoffice_template)
 
 
-serialize_importer_action = serialize_action("common_imports",
-                                             IMPORT_MODEL_LIST)
+serialize_importer_action = serialize_action("common_imports", IMPORT_MODEL_LIST)
 serialize_importer_action.short_description = SERIALIZE_DESC
 
 
 @admin.register(models.ImporterType, site=admin_site)
 class ImporterTypeAdmin(ImportJSONActionAdmin):
-    list_display = ('name', 'associated_models', 'available')
+    list_display = ("name", "associated_models", "available")
     actions = importer_type_actions + [serialize_importer_action]
-    form = make_ajax_form(models.ImporterType, {'users': 'ishtaruser'})
+    form = make_ajax_form(models.ImporterType, {"users": "ishtaruser"})
     prepopulated_fields = {"slug": ("name",)}
 
 
 class RegexpAdmin(admin.ModelAdmin):
-    list_display = ('name', "regexp", 'description')
+    list_display = ("name", "regexp", "description")
 
 
 admin_site.register(models.Regexp, RegexpAdmin)
 
 
 class ValueFormaterAdmin(admin.ModelAdmin):
-    list_display = ('name', "format_string", 'description')
+    list_display = ("name", "format_string", "description")
     prepopulated_fields = {"slug": ("name",)}
 
 
@@ -1307,7 +1389,7 @@ admin_site.register(models.ValueFormater, ValueFormaterAdmin)
 
 def duplicate_importercolumn(modeladmin, request, queryset):
     res = []
-    for col in queryset.order_by('col_number'):
+    for col in queryset.order_by("col_number"):
         old_pk = col.pk
         col.pk = None
         col.label = (col.label or "") + " - duplicate"
@@ -1315,7 +1397,8 @@ def duplicate_importercolumn(modeladmin, request, queryset):
         # get the next available col number
         col_nb = col.col_number + 1
         while modeladmin.model.objects.filter(
-                col_number=col_nb, importer_type=col.importer_type).count():
+            col_number=col_nb, importer_type=col.importer_type
+        ).count():
             col_nb += 1
         col.col_number = col_nb
         col.save()  # create new
@@ -1330,15 +1413,20 @@ def duplicate_importercolumn(modeladmin, request, queryset):
             tg.save()
         res.append(str(col))
     messages.add_message(
-        request, messages.INFO,
+        request,
+        messages.INFO,
         str(_("{} importer column(s) duplicated: {}.")).format(
-            queryset.count(), " ; ".join(res))
+            queryset.count(), " ; ".join(res)
+        ),
+    )
+    url = (
+        reverse(
+            "admin:%s_%s_changelist"
+            % (modeladmin.model._meta.app_label, modeladmin.model._meta.model_name)
+        )
+        + "?"
+        + urllib.parse.urlencode(request.GET)
     )
-    url = reverse(
-        'admin:%s_%s_changelist' % (
-            modeladmin.model._meta.app_label,
-            modeladmin.model._meta.model_name)
-    ) + '?' + urllib.parse.urlencode(request.GET)
     return HttpResponseRedirect(url)
 
 
@@ -1346,23 +1434,28 @@ duplicate_importercolumn.short_description = _("Duplicate")
 
 
 def shift_right(modeladmin, request, queryset):
-    for col in queryset.order_by('-col_number'):
+    for col in queryset.order_by("-col_number"):
         # get the next available col number
         col_nb = col.col_number + 1
         while modeladmin.model.objects.filter(
-                col_number=col_nb, importer_type=col.importer_type).count():
+            col_number=col_nb, importer_type=col.importer_type
+        ).count():
             col_nb += 1
         col.col_number = col_nb
         col.save()
     messages.add_message(
-        request, messages.INFO,
-        str(_("{} importer column(s) right-shifted.")).format(queryset.count())
+        request,
+        messages.INFO,
+        str(_("{} importer column(s) right-shifted.")).format(queryset.count()),
+    )
+    url = (
+        reverse(
+            "admin:%s_%s_changelist"
+            % (modeladmin.model._meta.app_label, modeladmin.model._meta.model_name)
+        )
+        + "?"
+        + urllib.parse.urlencode(request.GET)
     )
-    url = reverse(
-        'admin:%s_%s_changelist' % (
-            modeladmin.model._meta.app_label,
-            modeladmin.model._meta.model_name)
-    ) + '?' + urllib.parse.urlencode(request.GET)
     return HttpResponseRedirect(url)
 
 
@@ -1371,7 +1464,7 @@ shift_right.short_description = _("Shift right")
 
 def shift_left(modeladmin, request, queryset):
     errors, oks = 0, 0
-    for col in queryset.order_by('col_number'):
+    for col in queryset.order_by("col_number"):
         # get the next available col number
         if col.col_number == 1:
             errors += 1
@@ -1379,7 +1472,8 @@ def shift_left(modeladmin, request, queryset):
         col_nb = col.col_number - 1
         error = False
         while modeladmin.model.objects.filter(
-                col_number=col_nb, importer_type=col.importer_type).count():
+            col_number=col_nb, importer_type=col.importer_type
+        ).count():
             col_nb -= 1
         if col_nb <= 0:
             errors += 1
@@ -1390,20 +1484,26 @@ def shift_left(modeladmin, request, queryset):
         oks += 1
     if oks:
         messages.add_message(
-            request, messages.INFO,
-            str(_("{} importer column(s) left-shifted.")).format(oks)
+            request,
+            messages.INFO,
+            str(_("{} importer column(s) left-shifted.")).format(oks),
         )
     if errors:
         messages.add_message(
-            request, messages.ERROR,
-            str(_("{} importer column(s) not left-shifted: no "
-                  "place available.")).format(errors)
+            request,
+            messages.ERROR,
+            str(
+                _("{} importer column(s) not left-shifted: no " "place available.")
+            ).format(errors),
         )
-    url = reverse(
-        'admin:%s_%s_changelist' % (
-            modeladmin.model._meta.app_label,
-            modeladmin.model._meta.model_name)
-    ) + '?' + urllib.parse.urlencode(request.GET)
+    url = (
+        reverse(
+            "admin:%s_%s_changelist"
+            % (modeladmin.model._meta.app_label, modeladmin.model._meta.model_name)
+        )
+        + "?"
+        + urllib.parse.urlencode(request.GET)
+    )
     return HttpResponseRedirect(url)
 
 
@@ -1418,9 +1518,7 @@ class ImportTargetForm(forms.ModelForm):
     class Meta:
         model = models.ImportTarget
         exclude = []
-        widgets = {
-            'comment': forms.TextInput
-        }
+        widgets = {"comment": forms.TextInput}
 
 
 class ImportTargetInline(admin.TabularInline):
@@ -1430,10 +1528,17 @@ class ImportTargetInline(admin.TabularInline):
 
 
 class ImporterColumnAdmin(admin.ModelAdmin):
-    list_display = ('label', 'importer_type', 'col_number', 'col_string',
-                    'description', 'targets_lbl', 'duplicate_fields_lbl',
-                    'required')
-    list_filter = ('importer_type',)
+    list_display = (
+        "label",
+        "importer_type",
+        "col_number",
+        "col_string",
+        "description",
+        "targets_lbl",
+        "duplicate_fields_lbl",
+        "required",
+    )
+    list_filter = ("importer_type",)
     inlines = (ImportTargetInline, ImporterDuplicateFieldInline)
     actions = [duplicate_importercolumn, shift_left, shift_right]
 
@@ -1442,7 +1547,7 @@ admin_site.register(models.ImporterColumn, ImporterColumnAdmin)
 
 
 class ImporterModelAdmin(admin.ModelAdmin):
-    list_display = ('name', 'klass')
+    list_display = ("name", "klass")
     model = models.ImporterModel
 
 
@@ -1450,35 +1555,39 @@ admin_site.register(models.ImporterModel, ImporterModelAdmin)
 
 
 class FormaterTypeAdmin(admin.ModelAdmin):
-    list_display = ('formater_type', 'options')
+    list_display = ("formater_type", "options")
 
 
 admin_site.register(models.FormaterType, FormaterTypeAdmin)
 
 
 class ImportAdmin(admin.ModelAdmin):
-    list_display = ('name', 'importer_type', 'imported_file', 'user', 'state',
-                    'creation_date')
-    form = make_ajax_form(models.Import, {'user': 'ishtaruser'})
+    list_display = (
+        "name",
+        "importer_type",
+        "imported_file",
+        "user",
+        "state",
+        "creation_date",
+    )
+    form = make_ajax_form(models.Import, {"user": "ishtaruser"})
 
 
 admin_site.register(models.Import, ImportAdmin)
 
 
 class TargetKeyGroupAdmin(admin.ModelAdmin):
-    list_display = ('name', 'all_user_can_use', 'all_user_can_modify',
-                    'available')
-    search_fields = ('name',)
+    list_display = ("name", "all_user_can_use", "all_user_can_modify", "available")
+    search_fields = ("name",)
 
 
 admin_site.register(models.TargetKeyGroup, TargetKeyGroupAdmin)
 
 
 class TargetKeyAdmin(admin.ModelAdmin):
-    list_display = ('target', 'importer_type', 'column_nb', 'key',
-                    'value', 'is_set')
+    list_display = ("target", "importer_type", "column_nb", "key", "value", "is_set")
     list_filter = ("is_set", "target__column__importer_type")
-    search_fields = ('target__target', 'value', 'key')
+    search_fields = ("target__target", "value", "key")
 
 
 admin_site.register(models.TargetKey, TargetKeyAdmin)
@@ -1493,7 +1602,7 @@ admin_site.register(models.OperationType, OperationTypeAdmin)
 
 
 class SpatialReferenceSystemAdmin(GeneralTypeAdmin):
-    extra_list_display = ['order', 'srid']
+    extra_list_display = ["order", "srid"]
     model = models.SpatialReferenceSystem
 
 
@@ -1501,8 +1610,8 @@ admin_site.register(models.SpatialReferenceSystem, SpatialReferenceSystemAdmin)
 
 
 class ItemKeyAdmin(admin.ModelAdmin):
-    list_display = ('content_type', 'key', 'content_object', 'importer')
-    search_fields = ('key', )
+    list_display = ("content_type", "key", "content_object", "importer")
+    search_fields = ("key",)
 
 
 admin_site.register(models.ItemKey, ItemKeyAdmin)
@@ -1516,17 +1625,17 @@ class JsonContentTypeFormMixin(object):
     def __init__(self, *args, **kwargs):
         super(JsonContentTypeFormMixin, self).__init__(*args, **kwargs)
         choices = []
-        for pk, label in self.fields['content_type'].choices:
+        for pk, label in self.fields["content_type"].choices:
             if not pk:
                 choices.append((pk, label))
                 continue
             ct = ContentType.objects.get(pk=pk)
             model_class = ct.model_class()
-            if hasattr(model_class, 'data') and \
-                    not hasattr(model_class, 'history_type'):
+            if hasattr(model_class, "data") and not hasattr(
+                model_class, "history_type"
+            ):
                 choices.append((pk, label))
-        self.fields['content_type'].choices = sorted(choices,
-                                                     key=lambda x: x[1])
+        self.fields["content_type"].choices = sorted(choices, key=lambda x: x[1])
 
 
 class JsonDataSectionForm(JsonContentTypeFormMixin, forms.ModelForm):
@@ -1536,7 +1645,7 @@ class JsonDataSectionForm(JsonContentTypeFormMixin, forms.ModelForm):
 
 
 class JsonDataSectionAdmin(admin.ModelAdmin):
-    list_display = ['name', 'content_type', 'order']
+    list_display = ["name", "content_type", "order"]
     form = JsonDataSectionForm
 
 
@@ -1550,13 +1659,21 @@ class JsonDataFieldForm(JsonContentTypeFormMixin, forms.ModelForm):
 
 
 class JsonDataFieldAdmin(admin.ModelAdmin):
-    list_display = ['name', 'content_type', 'key', 'display',
-                    'value_type', 'search_index', 'order', 'section']
+    list_display = [
+        "name",
+        "content_type",
+        "key",
+        "display",
+        "value_type",
+        "search_index",
+        "order",
+        "section",
+    ]
     actions = [
-        change_value('display', True, _("Display selected")),
-        change_value('display', False, _("Hide selected"))
+        change_value("display", True, _("Display selected")),
+        change_value("display", False, _("Hide selected")),
     ]
-    list_filter = ['value_type', 'search_index']
+    list_filter = ["value_type", "search_index"]
     form = JsonDataFieldForm
 
 
@@ -1564,7 +1681,7 @@ admin_site.register(models.JsonDataField, JsonDataFieldAdmin)
 
 
 def get_choices_form():
-    cache_key, value = get_cache(models.CustomForm, ['associated-forms'])
+    cache_key, value = get_cache(models.CustomForm, ["associated-forms"])
     if value:
         return value
     register, register_fields = models.CustomForm.register()
@@ -1582,9 +1699,11 @@ class CustomFormForm(forms.ModelForm):
     class Meta:
         model = models.CustomForm
         exclude = []
+
     form = forms.ChoiceField(label=_("Form"), choices=get_choices_form)
-    users = AutoCompleteSelectMultipleField('ishtaruser', required=False,
-                                            label=_("Users"))
+    users = AutoCompleteSelectMultipleField(
+        "ishtaruser", required=False, label=_("Users")
+    )
 
 
 class ExcludeFieldFormset(BaseInlineFormSet):
@@ -1594,9 +1713,9 @@ class ExcludeFieldFormset(BaseInlineFormSet):
             return kwargs
         form = self.instance.get_form_class()
         if not form:
-            kwargs['choices'] = []
+            kwargs["choices"] = []
             return kwargs
-        kwargs['choices'] = [('', '--')] + form.get_custom_fields()
+        kwargs["choices"] = [("", "--")] + form.get_custom_fields()
         return kwargs
 
 
@@ -1604,12 +1723,13 @@ class ExcludeFieldForm(forms.ModelForm):
     class Meta:
         model = models.ExcludedField
         exclude = []
+
     field = forms.ChoiceField(label=_("Field"))
 
     def __init__(self, *args, **kwargs):
-        choices = kwargs.pop('choices')
+        choices = kwargs.pop("choices")
         super(ExcludeFieldForm, self).__init__(*args, **kwargs)
-        self.fields['field'].choices = choices
+        self.fields["field"].choices = choices
 
 
 class ExcludeFieldInline(admin.TabularInline):
@@ -1624,8 +1744,7 @@ class JsonFieldFormset(BaseInlineFormSet):
         kwargs = super(JsonFieldFormset, self).get_form_kwargs(index)
         if not self.instance or not self.instance.pk:
             return kwargs
-        kwargs['choices'] = [('', '--')] + \
-            self.instance.get_available_json_fields()
+        kwargs["choices"] = [("", "--")] + self.instance.get_available_json_fields()
         return kwargs
 
 
@@ -1635,9 +1754,9 @@ class JsonFieldForm(forms.ModelForm):
         exclude = []
 
     def __init__(self, *args, **kwargs):
-        choices = kwargs.pop('choices')
+        choices = kwargs.pop("choices")
         super(JsonFieldForm, self).__init__(*args, **kwargs)
-        self.fields['json_field'].choices = choices
+        self.fields["json_field"].choices = choices
 
 
 class JsonFieldInline(admin.TabularInline):
@@ -1648,10 +1767,25 @@ class JsonFieldInline(admin.TabularInline):
 
 
 class CustomFormAdmin(admin.ModelAdmin):
-    list_display = ['name', 'form', 'available', 'enabled', 'apply_to_all',
-                    'users_lbl', 'user_types_lbl']
-    fields = ('name', 'form', 'available', 'enabled', 'apply_to_all', 'users',
-              'user_types', 'profile_types')
+    list_display = [
+        "name",
+        "form",
+        "available",
+        "enabled",
+        "apply_to_all",
+        "users_lbl",
+        "user_types_lbl",
+    ]
+    fields = (
+        "name",
+        "form",
+        "available",
+        "enabled",
+        "apply_to_all",
+        "users",
+        "user_types",
+        "profile_types",
+    )
     form = CustomFormForm
     inlines = [ExcludeFieldInline, JsonFieldInline]
 
@@ -1659,12 +1793,11 @@ class CustomFormAdmin(admin.ModelAdmin):
         # no inline on creation
         if not obj:
             return []
-        return super(CustomFormAdmin, self).get_inline_instances(request,
-                                                                 obj=obj)
+        return super(CustomFormAdmin, self).get_inline_instances(request, obj=obj)
 
     def get_readonly_fields(self, request, obj=None):
         if obj:
-            return ('form', "user_types")
+            return ("form", "user_types")
         return ("user_types",)
 
 
@@ -1672,11 +1805,11 @@ admin_site.register(models.CustomForm, CustomFormAdmin)
 
 
 class AdministrationScriptAdmin(admin.ModelAdmin):
-    list_display = ['name', 'path']
+    list_display = ["name", "path"]
 
     def get_readonly_fields(self, request, obj=None):
         if obj:
-            return ('path',)
+            return ("path",)
         return []
 
 
@@ -1684,15 +1817,26 @@ admin_site.register(models.AdministrationScript, AdministrationScriptAdmin)
 
 
 class AdministrationTaskAdmin(admin.ModelAdmin):
-    readonly_fields = ('state', 'creation_date', 'launch_date',
-                       'finished_date', "result", )
-    list_display = ['script', 'state', 'creation_date', 'launch_date',
-                    'finished_date', "result"]
-    list_filter = ['script', 'state']
+    readonly_fields = (
+        "state",
+        "creation_date",
+        "launch_date",
+        "finished_date",
+        "result",
+    )
+    list_display = [
+        "script",
+        "state",
+        "creation_date",
+        "launch_date",
+        "finished_date",
+        "result",
+    ]
+    list_filter = ["script", "state"]
 
     def get_readonly_fields(self, request, obj=None):
         if obj:
-            return ("script", ) + self.readonly_fields
+            return ("script",) + self.readonly_fields
         return self.readonly_fields
 
 
@@ -1701,23 +1845,22 @@ admin_site.register(models.AdministrationTask, AdministrationTaskAdmin)
 
 def launch_export_action(modeladmin, request, queryset):
     model = modeladmin.model
-    back_url = reverse(
-        'admin:%s_%s_changelist' % (
-            model._meta.app_label,
-            model._meta.model_name)
-    ) + '?' + urllib.parse.urlencode(request.GET)
-    if queryset.count() != 1:
-        messages.add_message(
-            request, messages.ERROR, str(_("Select only one task."))
+    back_url = (
+        reverse(
+            "admin:%s_%s_changelist" % (model._meta.app_label, model._meta.model_name)
         )
+        + "?"
+        + urllib.parse.urlencode(request.GET)
+    )
+    if queryset.count() != 1:
+        messages.add_message(request, messages.ERROR, str(_("Select only one task.")))
         return HttpResponseRedirect(back_url)
 
     export_task = queryset.all()[0]
 
     if export_task.state != "C":
         messages.add_message(
-            request, messages.ERROR, str(
-                _("Export already exported/scheduled."))
+            request, messages.ERROR, str(_("Export already exported/scheduled."))
         )
         return HttpResponseRedirect(back_url)
 
@@ -1734,12 +1877,19 @@ launch_export_action.short_description = _("Launch export")
 
 class ExportTaskAdmin(admin.ModelAdmin):
     readonly_fields = ("result", "result_info")
-    exclude = ('creation_date', 'launch_date', 'finished_date')
-    list_display = ["label", 'state', "result_info", "result", 'creation_date',
-                    'launch_date', 'finished_date']
-    list_filter = ['state']
+    exclude = ("creation_date", "launch_date", "finished_date")
+    list_display = [
+        "label",
+        "state",
+        "result_info",
+        "result",
+        "creation_date",
+        "launch_date",
+        "finished_date",
+    ]
+    list_filter = ["state"]
     actions = [launch_export_action]
-    form = make_ajax_form(models.ExportTask, {'lock_user': 'user'})
+    form = make_ajax_form(models.ExportTask, {"lock_user": "user"})
 
 
 admin_site.register(models.ExportTask, ExportTaskAdmin)
@@ -1747,23 +1897,22 @@ admin_site.register(models.ExportTask, ExportTaskAdmin)
 
 def launch_import_action(modeladmin, request, queryset):
     model = modeladmin.model
-    back_url = reverse(
-        'admin:%s_%s_changelist' % (
-            model._meta.app_label,
-            model._meta.model_name)
-    ) + '?' + urllib.parse.urlencode(request.GET)
-    if queryset.count() != 1:
-        messages.add_message(
-            request, messages.ERROR, str(_("Select only one task."))
+    back_url = (
+        reverse(
+            "admin:%s_%s_changelist" % (model._meta.app_label, model._meta.model_name)
         )
+        + "?"
+        + urllib.parse.urlencode(request.GET)
+    )
+    if queryset.count() != 1:
+        messages.add_message(request, messages.ERROR, str(_("Select only one task.")))
         return HttpResponseRedirect(back_url)
 
     import_task = queryset.all()[0]
 
     if import_task.state != "C":
         messages.add_message(
-            request, messages.ERROR, str(
-                _("Import already imported/scheduled."))
+            request, messages.ERROR, str(_("Import already imported/scheduled."))
         )
         return HttpResponseRedirect(back_url)
 
@@ -1779,28 +1928,32 @@ launch_import_action.short_description = _("Launch import")
 
 
 class ImportTaskAdmin(admin.ModelAdmin):
-    exclude = ('creation_date', 'launch_date', 'finished_date')
-    list_display = ['creation_date', "source", 'state', "import_user",
-                    'launch_date', 'finished_date']
-    list_filter = ['state']
-    form = make_ajax_form(models.ImportTask, {'import_user': 'user'})
+    exclude = ("creation_date", "launch_date", "finished_date")
+    list_display = [
+        "creation_date",
+        "source",
+        "state",
+        "import_user",
+        "launch_date",
+        "finished_date",
+    ]
+    list_filter = ["state"]
+    form = make_ajax_form(models.ImportTask, {"import_user": "user"})
     actions = [launch_import_action]
 
     class Media:
-        js = (
-            'js/admin/archive_import.js',
-        )
+        js = ("js/admin/archive_import.js",)
 
 
 admin_site.register(models.ImportTask, ImportTaskAdmin)
 
 
 class UserProfileAdmin(admin.ModelAdmin):
-    list_display = ['person', 'profile_type', 'area_labels']
-    list_filter = ['profile_type']
-    search_fields = ['person__raw_name']
+    list_display = ["person", "profile_type", "area_labels"]
+    list_filter = ["profile_type"]
+    search_fields = ["person__raw_name"]
     model = models.UserProfile
-    form = make_ajax_form(model, {'areas': 'area'})
+    form = make_ajax_form(model, {"areas": "area"})
 
 
 admin_site.register(models.UserProfile, UserProfileAdmin)