Format - black: finds

1 files changed, 600 insertions, 465 deletions

diff --git a/archaeological_finds/views.py b/archaeological_finds/views.py
index 978afc759..561227f7c 100644
--- a/archaeological_finds/views.py
+++ b/archaeological_finds/views.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 # Copyright (C) 2010-2018  Étienne Loks  <etienne.loks_AT_peacefrogsDOTnet>
 
@@ -41,22 +41,34 @@ from archaeological_operations.models import AdministrativeAct
 from archaeological_finds import models
 
 from ishtar_common.forms import FinalForm
-from archaeological_context_records.forms \
-    import RecordFormSelection as RecordFormSelectionTable
+from archaeological_context_records.forms import (
+    RecordFormSelection as RecordFormSelectionTable,
+)
 from archaeological_operations.forms import FinalAdministrativeActDeleteForm
 from archaeological_finds import forms
 
-from ishtar_common.views import get_autocomplete_generic, IshtarMixin, \
-    LoginRequiredMixin, QAItemEditForm, QAItemForm, QABaseLockView, \
-    wizard_is_available
-from ishtar_common.views_item import display_item, get_item, show_item, \
-    revert_item, get_autocomplete_item, get_autocomplete_queries
+from ishtar_common.views import (
+    get_autocomplete_generic,
+    IshtarMixin,
+    LoginRequiredMixin,
+    QAItemEditForm,
+    QAItemForm,
+    QABaseLockView,
+    wizard_is_available,
+)
+from ishtar_common.views_item import (
+    display_item,
+    get_item,
+    show_item,
+    revert_item,
+    get_autocomplete_item,
+    get_autocomplete_queries,
+)
 
 from archaeological_operations.wizards import AdministrativeActDeletionWizard
 from archaeological_finds import wizards
 
-get_find = get_item(models.Find, 'get_find', 'find',
-                    search_form=forms.FindSelect)
+get_find = get_item(models.Find, "get_find", "find", search_form=forms.FindSelect)
 
 
 def get_table_cols_for_ope():
@@ -75,77 +87,95 @@ def get_table_cols_for_cr():
 
 def get_table_cols_for_container():
     table_cols = models.Find.TABLE_COLS
-    tb_key = ("find", 'TABLE_COLS')
+    tb_key = ("find", "TABLE_COLS")
     if tb_key in settings.TABLE_COLS:
         table_cols = settings.TABLE_COLS[tb_key]
     return ["find__" + tc for tc in table_cols]
 
 
-get_find_for_ope = get_item(models.Find, 'get_find', 'find',
-                            own_table_cols=get_table_cols_for_ope())
+get_find_for_ope = get_item(
+    models.Find, "get_find", "find", own_table_cols=get_table_cols_for_ope()
+)
 
 
-get_find_for_cr = get_item(models.Find, 'get_find', 'find',
-                           own_table_cols=get_table_cols_for_cr())
+get_find_for_cr = get_item(
+    models.Find, "get_find", "find", own_table_cols=get_table_cols_for_cr()
+)
 
 get_find_for_treatment = get_item(
-    models.Find, 'get_find', 'find',
-    own_table_cols=get_table_cols_for_ope(), base_request={})
+    models.Find,
+    "get_find",
+    "find",
+    own_table_cols=get_table_cols_for_ope(),
+    base_request={},
+)
 
 get_find_inside_container = get_item(
-    models.FindInsideContainer, 'get_find_inside_container',
-    'find',
+    models.FindInsideContainer,
+    "get_find_inside_container",
+    "find",
     extra_request_keys=models.FindInsideContainer.EXTRA_REQUEST_KEYS,
-    own_table_cols=get_table_cols_for_container())
+    own_table_cols=get_table_cols_for_container(),
+)
 
 autocomplete_find = get_autocomplete_item(model=models.Find)
 
 
-show_treatment = show_item(models.Treatment, 'treatment')
+show_treatment = show_item(models.Treatment, "treatment")
 revert_treatment = revert_item(models.Treatment)
 get_treatment = get_item(
-    models.Treatment, 'get_treatment', 'treatment',
-    search_form=forms.TreatmentSelect
+    models.Treatment, "get_treatment", "treatment", search_form=forms.TreatmentSelect
 )
 display_treatment = display_item(models.Treatment)
 
 autocomplete_treatment = get_autocomplete_item(model=models.Treatment)
 
 get_administrativeacttreatment = get_item(
-    AdministrativeAct, 'get_administrativeacttreatment',
-    'administrativeacttreatment',
-    base_request={"treatment__pk__isnull": False})
+    AdministrativeAct,
+    "get_administrativeacttreatment",
+    "administrativeacttreatment",
+    base_request={"treatment__pk__isnull": False},
+)
 
-show_treatmentfile = show_item(models.TreatmentFile, 'treatmentfile')
+show_treatmentfile = show_item(models.TreatmentFile, "treatmentfile")
 revert_treatmentfile = revert_item(models.TreatmentFile)
 get_treatmentfile = get_item(
-    models.TreatmentFile, 'get_treatmentfile', 'treatmentfile',
-    search_form=forms.TreatmentFileSelect
+    models.TreatmentFile,
+    "get_treatmentfile",
+    "treatmentfile",
+    search_form=forms.TreatmentFileSelect,
 )
 
 get_administrativeacttreatmentfile = get_item(
-    AdministrativeAct, 'get_administrativeacttreatmentfile',
-    'administrativeacttreatmentfile',
-    base_request={"treatment_file__pk__isnull": False})
+    AdministrativeAct,
+    "get_administrativeacttreatmentfile",
+    "administrativeacttreatmentfile",
+    base_request={"treatment_file__pk__isnull": False},
+)
 
 
 def autocomplete_treatmentfile(request):
-    if not request.user.has_perm('ishtar_common.view_treatment',
-                                 models.Treatment) and \
-            not request.user.has_perm('ishtar_common.view_own_treatment',
-                                      models.Treatment) \
-            and not request.user.ishtaruser.has_right('treatmentfile_search',
-                                                      session=request.session):
-        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("ishtar_common.view_treatment", models.Treatment)
+        and not request.user.has_perm(
+            "ishtar_common.view_own_treatment", models.Treatment
+        )
+        and not request.user.ishtaruser.has_right(
+            "treatmentfile_search", session=request.session
+        )
+    ):
+        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()
-    for q1 in q.split(' '):
-        for q in q1.split(' '):
-            extra = Q(internal_reference__icontains=q) | \
-                Q(external_id__icontains=q) | \
-                Q(name__icontains=q)
+    for q1 in q.split(" "):
+        for q in q1.split(" "):
+            extra = (
+                Q(internal_reference__icontains=q)
+                | Q(external_id__icontains=q)
+                | Q(name__icontains=q)
+            )
             try:
                 int(q)
                 extra = extra | Q(year=q) | Q(index=q)
@@ -154,52 +184,53 @@ def autocomplete_treatmentfile(request):
             query = query & extra
     limit = 20
     files = models.TreatmentFile.objects.filter(query)[:limit]
-    data = json.dumps([{'id': file.pk, 'value': str(file)}
-                       for file in files])
-    return HttpResponse(data, content_type='text/plain')
+    data = json.dumps([{"id": file.pk, "value": str(file)} for file in files])
+    return HttpResponse(data, content_type="text/plain")
 
 
 def show_basefind(request, pk, **dct):
-    q = models.Find.objects.filter(base_finds__pk=pk,
-                                   downstream_treatment__isnull=True)
+    q = models.Find.objects.filter(base_finds__pk=pk, downstream_treatment__isnull=True)
     if not q.count():
         return Http404()
-    find_pk = q.values("pk").order_by('-pk')[0]["pk"]
-    return show_item(models.Find, 'find')(request, find_pk, **dct)
+    find_pk = q.values("pk").order_by("-pk")[0]["pk"]
+    return show_item(models.Find, "find")(request, find_pk, **dct)
 
 
 def show_find_extra(request, find):
     if not request.user or not request.user.ishtaruser:
         return {}
     user = request.user.ishtaruser
-    q = models.FindBasket.objects.filter(items__pk=find.pk).filter(
-        Q(user=user) | Q(shared_with__pk=user.pk) |
-        Q(shared_write_with__pk=user.pk)
-    ).distinct()
+    q = (
+        models.FindBasket.objects.filter(items__pk=find.pk)
+        .filter(
+            Q(user=user) | Q(shared_with__pk=user.pk) | Q(shared_write_with__pk=user.pk)
+        )
+        .distinct()
+    )
     return {"baskets": [(basket.pk, basket.full_label) for basket in q.all()]}
 
 
-show_find = show_item(models.Find, 'find', extra_dct=show_find_extra)
+show_find = show_item(models.Find, "find", extra_dct=show_find_extra)
 display_find = display_item(models.Find)
 revert_find = revert_item(models.Find)
 
-show_findbasket = show_item(models.FindBasket, 'findbasket',
-                            model_for_perms=models.Find)
-display_findbasket = display_item(models.FindBasket,
-                                  show_url='show-find/basket-')
+show_findbasket = show_item(
+    models.FindBasket, "findbasket", model_for_perms=models.Find
+)
+display_findbasket = display_item(models.FindBasket, show_url="show-find/basket-")
 
 
 def autocomplete_findbasket(request, current_right=None):
-    if not request.GET.get('term'):
-        return HttpResponse(content_type='text/plain')
+    if not request.GET.get("term"):
+        return HttpResponse(content_type="text/plain")
 
     limit = 20
     result = OrderedDict()
-    for query in get_autocomplete_queries(request, ['label']):
-        query = query & models.FindBasket.get_query_owns(
-            request.user.ishtaruser)
-        objects = models.FindBasket.objects.filter(query).distinct().order_by(
-            'label')[:limit]
+    for query in get_autocomplete_queries(request, ["label"]):
+        query = query & models.FindBasket.get_query_owns(request.user.ishtaruser)
+        objects = (
+            models.FindBasket.objects.filter(query).distinct().order_by("label")[:limit]
+        )
         for obj in objects:
             if obj.id not in list(result.keys()):
                 result[obj.id] = obj.label
@@ -208,22 +239,21 @@ def autocomplete_findbasket(request, current_right=None):
                     break
         if not limit:
             break
-    data = json.dumps([{'id': obj[0], 'value': obj[1]}
-                       for obj in list(result.items())])
-    return HttpResponse(data, content_type='text/plain')
+    data = json.dumps([{"id": obj[0], "value": obj[1]} for obj in list(result.items())])
+    return HttpResponse(data, content_type="text/plain")
 
 
 def autocomplete_findbasket_write(request, current_right=None):
-    if not request.GET.get('term'):
-        return HttpResponse(content_type='text/plain')
+    if not request.GET.get("term"):
+        return HttpResponse(content_type="text/plain")
 
     limit = 20
     result = OrderedDict()
-    for query in get_autocomplete_queries(request, ['label']):
-        query = query & models.FindBasket.get_write_query_owns(
-            request.user.ishtaruser)
-        objects = models.FindBasket.objects.filter(query).distinct().order_by(
-            'label')[:limit]
+    for query in get_autocomplete_queries(request, ["label"]):
+        query = query & models.FindBasket.get_write_query_owns(request.user.ishtaruser)
+        objects = (
+            models.FindBasket.objects.filter(query).distinct().order_by("label")[:limit]
+        )
         for obj in objects:
             if obj.id not in list(result.keys()):
                 result[obj.id] = obj.label
@@ -232,63 +262,64 @@ def autocomplete_findbasket_write(request, current_right=None):
                     break
         if not limit:
             break
-    data = json.dumps([{'id': obj[0], 'value': obj[1]}
-                       for obj in list(result.items())])
-    return HttpResponse(data, content_type='text/plain')
+    data = json.dumps([{"id": obj[0], "value": obj[1]} for obj in list(result.items())])
+    return HttpResponse(data, content_type="text/plain")
 
 
 get_find_basket = get_item(
-    models.FindBasket, 'get_findbasket', 'findbasket',
-    model_for_perms=models.Find
+    models.FindBasket, "get_findbasket", "findbasket", model_for_perms=models.Find
 )
 
 get_findbasket = get_find_basket
 
 get_find_basket_for_write = get_item(
-    models.FindBasket, 'get_findbasket', 'findbasket',
-    model_for_perms=models.Find, alt_query_own='get_write_query_owns'
+    models.FindBasket,
+    "get_findbasket",
+    "findbasket",
+    model_for_perms=models.Find,
+    alt_query_own="get_write_query_owns",
 )
 
 basket_search_wizard = wizards.FindBasketSearch.as_view(
-    [('selec-find_basket_search', forms.FindBasketFormSelection)],
+    [("selec-find_basket_search", forms.FindBasketFormSelection)],
     label=_("Basket search"),
-    url_name='find_basket_search',
+    url_name="find_basket_search",
 )
 
 basket_modify_wizard = wizards.FindBasketEditWizard.as_view(
     [
-        ('selec-find_basket_modification',
-         forms.FindBasketForWriteFormSelection),
-        ('basket-find_basket_modification', forms.FindBasketForm),
-        ('final-find_basket_modification', FinalForm)
+        ("selec-find_basket_modification", forms.FindBasketForWriteFormSelection),
+        ("basket-find_basket_modification", forms.FindBasketForm),
+        ("final-find_basket_modification", FinalForm),
     ],
     label=_("Basket modify"),
-    url_name='find_basket_modification',
+    url_name="find_basket_modification",
 )
 
 
 def find_basket_modify(request, pk):
-    if not wizard_is_available(basket_modify_wizard, request, models.FindBasket,
-                               pk):
+    if not wizard_is_available(basket_modify_wizard, request, models.FindBasket, pk):
         return HttpResponseRedirect("/")
-    key = 'selec-find_basket_modification'
-    wizards.FindBasketEditWizard.session_set_value(
-        request, key, 'pk', pk, reset=True)
+    key = "selec-find_basket_modification"
+    wizards.FindBasketEditWizard.session_set_value(request, key, "pk", pk, reset=True)
     return redirect(
-        reverse('find_basket_modification',
-                kwargs={'step': 'basket-find_basket_modification'}))
+        reverse(
+            "find_basket_modification",
+            kwargs={"step": "basket-find_basket_modification"},
+        )
+    )
 
 
 findbasket_deletion_steps = [
-    ('selec-find_basket_deletion', forms.FindBasketForWriteFormSelection),
-    ('final-find_basket_deletion', FinalForm)
+    ("selec-find_basket_deletion", forms.FindBasketForWriteFormSelection),
+    ("final-find_basket_deletion", FinalForm),
 ]
 
 
 basket_delete_wizard = wizards.FindBasketDeletionWizard.as_view(
     findbasket_deletion_steps,
     label=_("Basket deletion"),
-    url_name='find_basket_deletion',
+    url_name="find_basket_deletion",
 )
 
 
@@ -305,34 +336,37 @@ def check_not_warehouse_module(self):
 
 
 find_creation_steps = [
-    ('selecrecord-find_creation', RecordFormSelectionTable),
-    ('find-find_creation', forms.FindForm),
-    ('preservation-find_creation', forms.PreservationForm),
-    ('dating-find_creation', forms.DatingFormSet),
-    ('final-find_creation', FinalForm)
+    ("selecrecord-find_creation", RecordFormSelectionTable),
+    ("find-find_creation", forms.FindForm),
+    ("preservation-find_creation", forms.PreservationForm),
+    ("dating-find_creation", forms.DatingFormSet),
+    ("final-find_creation", FinalForm),
 ]
 
 find_creation_condition_dict = {
-    'preservation-find_creation': check_preservation_module,
+    "preservation-find_creation": check_preservation_module,
 }
 
 find_creation_wizard = wizards.FindWizard.as_view(
     find_creation_steps,
     label=_("New find"),
     condition_dict=find_creation_condition_dict,
-    url_name='find_creation',)
+    url_name="find_creation",
+)
 
 find_search_condition_dict = {
-    'general-find_search': check_not_warehouse_module,
-    'generalwarehouse-find_search': check_warehouse_module,
+    "general-find_search": check_not_warehouse_module,
+    "generalwarehouse-find_search": check_warehouse_module,
 }
 
-find_search_wizard = wizards.FindSearch.as_view([
-    ('general-find_search', forms.FindFormSelection),
-    ('generalwarehouse-find_search', forms.FindFormSelectionWarehouseModule)],
+find_search_wizard = wizards.FindSearch.as_view(
+    [
+        ("general-find_search", forms.FindFormSelection),
+        ("generalwarehouse-find_search", forms.FindFormSelectionWarehouseModule),
+    ],
     label=_("Find search"),
-    url_name='find_search',
-    condition_dict=find_search_condition_dict
+    url_name="find_search",
+    condition_dict=find_search_condition_dict,
 )
 
 
@@ -348,83 +382,80 @@ def has_only_one_base_find(wizard):
 
 
 find_modification_condition_dict = {
-    'selec-find_modification': check_not_warehouse_module,
-    'selecw-find_modification': check_warehouse_module,
-    'preservation-find_modification': check_preservation_module,
-    'selecrecord-find_modification': has_only_one_base_find,
-    'find-find_modification': has_only_one_base_find,
-    'simplefind-find_modification': has_many_base_find,
+    "selec-find_modification": check_not_warehouse_module,
+    "selecw-find_modification": check_warehouse_module,
+    "preservation-find_modification": check_preservation_module,
+    "selecrecord-find_modification": has_only_one_base_find,
+    "find-find_modification": has_only_one_base_find,
+    "simplefind-find_modification": has_many_base_find,
 }
 
 find_modification_steps = [
-    ('selec-find_modification', forms.FindFormSelection),
-    ('selecw-find_modification', forms.FindFormSelectionWarehouseModule),
-    ('selecrecord-find_modification', forms.RecordFormSelection),
-    ('find-find_modification', forms.FindForm),
-    ('simplefind-find_modification', forms.SimpleFindForm),
-    ('preservation-find_modification', forms.PreservationForm),
-    ('dating-find_modification', forms.DatingFormSet),
-    ('final-find_modification', FinalForm)
+    ("selec-find_modification", forms.FindFormSelection),
+    ("selecw-find_modification", forms.FindFormSelectionWarehouseModule),
+    ("selecrecord-find_modification", forms.RecordFormSelection),
+    ("find-find_modification", forms.FindForm),
+    ("simplefind-find_modification", forms.SimpleFindForm),
+    ("preservation-find_modification", forms.PreservationForm),
+    ("dating-find_modification", forms.DatingFormSet),
+    ("final-find_modification", FinalForm),
 ]
 
 find_modification_wizard = wizards.FindModificationWizard.as_view(
     find_modification_steps,
     condition_dict=find_modification_condition_dict,
     label=_("Find modification"),
-    url_name='find_modification'
+    url_name="find_modification",
 )
 
 
 def find_modify(request, pk):
-    find = wizard_is_available(find_modification_wizard, request,
-                               models.Find, pk)
+    find = wizard_is_available(find_modification_wizard, request, models.Find, pk)
     if not find:
         return HttpResponseRedirect("/")
     find_modification_wizard(request)
-    key = 'selec-find_modification'
+    key = "selec-find_modification"
     if get_current_profile().warehouse:
-        key = 'selecw-find_modification'
-    wizards.FindModificationWizard.session_set_value(
-        request, key, 'pk', pk, reset=True)
+        key = "selecw-find_modification"
+    wizards.FindModificationWizard.session_set_value(request, key, "pk", pk, reset=True)
 
-    step = 'find-find_modification'
+    step = "find-find_modification"
     if find.base_finds.count() > 1:
-        step = 'simplefind-find_modification'
-        
-    return redirect(
-        reverse('find_modification', kwargs={'step': step}))
+        step = "simplefind-find_modification"
+
+    return redirect(reverse("find_modification", kwargs={"step": step}))
+
 
 find_deletion_condition_dict = {
-    'selec-find_deletion': check_not_warehouse_module,
-    'selecw-find_deletion': check_warehouse_module,
+    "selec-find_deletion": check_not_warehouse_module,
+    "selecw-find_deletion": check_warehouse_module,
 }
 
 find_deletion_steps = [
-    ('selec-find_deletion', forms.FindFormMultiSelection),
-    ('selecw-find_deletion', forms.FindFormMultiSelectionWarehouseModule),
-    ('final-find_deletion', forms.FindDeletionForm)]
+    ("selec-find_deletion", forms.FindFormMultiSelection),
+    ("selecw-find_deletion", forms.FindFormMultiSelectionWarehouseModule),
+    ("final-find_deletion", forms.FindDeletionForm),
+]
 
 find_deletion_wizard = wizards.FindDeletionWizard.as_view(
     find_deletion_steps,
     condition_dict=find_deletion_condition_dict,
     label=_("Find deletion"),
-    url_name='find_deletion',)
+    url_name="find_deletion",
+)
 
 
 def find_delete(request, pk):
-    find = wizard_is_available(find_deletion_wizard, request,
-                               models.Find, pk)
+    find = wizard_is_available(find_deletion_wizard, request, models.Find, pk)
     if not find:
         return HttpResponseRedirect("/")
-    key = 'selec-find_deletion'
+    key = "selec-find_deletion"
     if get_current_profile().warehouse:
-        key = 'selecw-find_deletion'
-    wizards.FindDeletionWizard.session_set_value(
-        request, key, 'pks', pk, reset=True)
+        key = "selecw-find_deletion"
+    wizards.FindDeletionWizard.session_set_value(request, key, "pks", pk, reset=True)
 
-    step = 'final-find_deletion'
-    return redirect(
-        reverse('find_deletion', kwargs={'step': step}))
+    step = "final-find_deletion"
+    return redirect(reverse("find_deletion", kwargs={"step": step}))
 
 
 autocomplete_objecttype = get_autocomplete_generic(models.ObjectType)
@@ -434,19 +465,18 @@ autocomplete_integritytype = get_autocomplete_generic(models.IntegrityType)
 
 
 class NewFindBasketView(IshtarMixin, LoginRequiredMixin, CreateView):
-    template_name = 'ishtar/form.html'
+    template_name = "ishtar/form.html"
     model = models.FindBasket
     form_class = forms.NewFindBasketForm
     page_name = _("New basket")
 
     def get_form_kwargs(self):
         kwargs = super(NewFindBasketView, self).get_form_kwargs()
-        kwargs['user'] = IshtarUser.objects.get(pk=self.request.user.pk)
+        kwargs["user"] = IshtarUser.objects.get(pk=self.request.user.pk)
         return kwargs
 
     def get_success_url(self):
-        return reverse('select_itemsinbasket',
-                       kwargs={'pk': self.object.pk})
+        return reverse("select_itemsinbasket", kwargs={"pk": self.object.pk})
 
     def form_valid(self, form):
         self.object = form.save()
@@ -456,54 +486,53 @@ class NewFindBasketView(IshtarMixin, LoginRequiredMixin, CreateView):
 class OwnBasket(object):
     def get_basket(self, user, pk):
         try:
-            return models.FindBasket.objects.filter(
-                Q(user=user) | Q(shared_with=user) | Q(shared_write_with=user)
-            ).distinct().get(pk=pk)
+            return (
+                models.FindBasket.objects.filter(
+                    Q(user=user) | Q(shared_with=user) | Q(shared_write_with=user)
+                )
+                .distinct()
+                .get(pk=pk)
+            )
         except models.FindBasket.DoesNotExist:
             raise PermissionDenied
 
 
 class SelectBasketForManagement(IshtarMixin, LoginRequiredMixin, FormView):
-    template_name = 'ishtar/form.html'
+    template_name = "ishtar/form.html"
     form_class = forms.SelectFindBasketWriteForm
     page_name = _("Manage items in basket")
 
     def get_form_kwargs(self):
         kwargs = super(SelectBasketForManagement, self).get_form_kwargs()
-        kwargs['user'] = IshtarUser.objects.get(pk=self.request.user.pk)
-        if 'pk' in self.kwargs:
-            kwargs['initial'].update({'basket': self.kwargs['pk']})
+        kwargs["user"] = IshtarUser.objects.get(pk=self.request.user.pk)
+        if "pk" in self.kwargs:
+            kwargs["initial"].update({"basket": self.kwargs["pk"]})
         return kwargs
 
     def get_success_url(self, basket):
-        return reverse('select_itemsinbasket',
-                       kwargs={'pk': basket})
+        return reverse("select_itemsinbasket", kwargs={"pk": basket})
 
     def form_valid(self, form):
-        return HttpResponseRedirect(self.get_success_url(
-            form.cleaned_data['basket']))
+        return HttpResponseRedirect(self.get_success_url(form.cleaned_data["basket"]))
 
 
-class SelectItemsInBasket(OwnBasket, IshtarMixin, LoginRequiredMixin,
-                          TemplateView):
-    template_name = 'ishtar/manage_basket.html'
+class SelectItemsInBasket(OwnBasket, IshtarMixin, LoginRequiredMixin, TemplateView):
+    template_name = "ishtar/manage_basket.html"
     page_name = _("Manage basket")
 
     def get_context_data(self, *args, **kwargs):
-        context = super(SelectItemsInBasket, self).get_context_data(
-            *args, **kwargs)
+        context = super(SelectItemsInBasket, self).get_context_data(*args, **kwargs)
         self.user = IshtarUser.objects.get(pk=self.request.user.pk)
-        self.basket = self.get_basket(
-            user=self.user, pk=self.kwargs['pk']
-        )
-        context['basket'] = self.basket
+        self.basket = self.get_basket(user=self.user, pk=self.kwargs["pk"])
+        context["basket"] = self.basket
         if get_current_profile().warehouse:
-            context['form'] = forms.MultipleFindFormSelectionWarehouseModule()
+            context["form"] = forms.MultipleFindFormSelectionWarehouseModule()
         else:
-            context['form'] = forms.MultipleFindFormSelection()
-        context['add_url'] = reverse('add_iteminbasket')
-        context['list_url'] = reverse('list_iteminbasket',
-                                      kwargs={'pk': self.basket.pk})
+            context["form"] = forms.MultipleFindFormSelection()
+        context["add_url"] = reverse("add_iteminbasket")
+        context["list_url"] = reverse(
+            "list_iteminbasket", kwargs={"pk": self.basket.pk}
+        )
         return context
 
     def form_valid(self, form):
@@ -511,11 +540,11 @@ class SelectItemsInBasket(OwnBasket, IshtarMixin, LoginRequiredMixin,
 
 
 class FindBasketAddItemView(IshtarMixin, LoginRequiredMixin, FormView):
-    template_name = 'ishtar/simple_form.html'
+    template_name = "ishtar/simple_form.html"
     form_class = forms.FindBasketAddItemForm
 
     def get_success_url(self, basket):
-        return reverse('list_iteminbasket', kwargs={'pk': basket.pk})
+        return reverse("list_iteminbasket", kwargs={"pk": basket.pk})
 
     def form_valid(self, form):
         user = IshtarUser.objects.get(pk=self.request.user.pk)
@@ -524,135 +553,146 @@ class FindBasketAddItemView(IshtarMixin, LoginRequiredMixin, FormView):
         return HttpResponseRedirect(self.get_success_url(basket))
 
 
-class FindBasketListView(OwnBasket, IshtarMixin, LoginRequiredMixin,
-                         TemplateView):
-    template_name = 'ishtar/basket_list.html'
+class FindBasketListView(OwnBasket, IshtarMixin, LoginRequiredMixin, TemplateView):
+    template_name = "ishtar/basket_list.html"
 
     def get_context_data(self, *args, **kwargs):
-        context = super(FindBasketListView, self).get_context_data(
-            *args, **kwargs)
+        context = super(FindBasketListView, self).get_context_data(*args, **kwargs)
         self.user = IshtarUser.objects.get(pk=self.request.user.pk)
-        self.basket = self.get_basket(
-            user=self.user, pk=self.kwargs['pk']
+        self.basket = self.get_basket(user=self.user, pk=self.kwargs["pk"])
+        context["basket"] = self.basket
+        context["item_url"] = "/".join(
+            reverse(models.Find.SHOW_URL, args=[1]).split("/")[:-1]
+        )
+        context["delete_url"] = "/".join(
+            reverse("delete_iteminbasket", args=[1, 1]).split("/")[:-3]
         )
-        context['basket'] = self.basket
-        context['item_url'] = '/'.join(
-            reverse(models.Find.SHOW_URL, args=[1]).split('/')[:-1])
-        context['delete_url'] = '/'.join(
-            reverse('delete_iteminbasket', args=[1, 1]).split('/')[:-3])
         return context
 
 
-class FindBasketDeleteItemView(OwnBasket, IshtarMixin, LoginRequiredMixin,
-                               TemplateView):
-    template_name = 'ishtar/simple_form.html'
+class FindBasketDeleteItemView(
+    OwnBasket, IshtarMixin, LoginRequiredMixin, TemplateView
+):
+    template_name = "ishtar/simple_form.html"
 
     def get_success_url(self, basket):
-        return reverse('list_iteminbasket', kwargs={'pk': basket.pk})
+        return reverse("list_iteminbasket", kwargs={"pk": basket.pk})
 
     def get(self, *args, **kwargs):
         user = self.request.user
         ishtaruser = IshtarUser.objects.get(pk=self.request.user.pk)
         try:
-            find = models.Find.objects.get(
-                pk=self.kwargs['find_pk'])
+            find = models.Find.objects.get(pk=self.kwargs["find_pk"])
         except models.Find.DoesNotExist:
             raise PermissionDenied
 
-        basket = self.get_basket(
-            user=ishtaruser, pk=self.kwargs['basket']
-        )
-        if not user.is_superuser and \
-                not ishtaruser.has_right('view_find') and \
-                not (ishtaruser.has_right('view_own_find')
-                     and find.is_own(user)):
+        basket = self.get_basket(user=ishtaruser, pk=self.kwargs["basket"])
+        if (
+            not user.is_superuser
+            and not ishtaruser.has_right("view_find")
+            and not (ishtaruser.has_right("view_own_find") and find.is_own(user))
+        ):
             raise PermissionDenied
         basket.items.remove(find)
         return HttpResponseRedirect(self.get_success_url(basket))
 
+
 get_upstreamtreatment = get_item(
-    models.FindUpstreamTreatments, 'get_upstreamtreatment', 'uptreatment')
+    models.FindUpstreamTreatments, "get_upstreamtreatment", "uptreatment"
+)
 
 get_downstreamtreatment = get_item(
-    models.FindDownstreamTreatments, 'get_downstreamtreatment',
-    'downtreatment')
+    models.FindDownstreamTreatments, "get_downstreamtreatment", "downtreatment"
+)
 
 treatment_wizard_steps = [
-    ('selecfind-treatment_creation', forms.UpstreamFindFormSelection),
-    ('file-treatment_creation', forms.TreatmentFormFileChoice),
-    ('basetreatment-treatment_creation', forms.BaseTreatmentForm),
-    ('final-treatment_creation', FinalForm)
+    ("selecfind-treatment_creation", forms.UpstreamFindFormSelection),
+    ("file-treatment_creation", forms.TreatmentFormFileChoice),
+    ("basetreatment-treatment_creation", forms.BaseTreatmentForm),
+    ("final-treatment_creation", FinalForm),
 ]
 
 
-treatment_search_wizard = wizards.TreatmentSearch.as_view([
-    ('general-treatment_search', forms.TreatmentFormSelection)],
+treatment_search_wizard = wizards.TreatmentSearch.as_view(
+    [("general-treatment_search", forms.TreatmentFormSelection)],
     label=_("Treatment search"),
-    url_name='treatment_search',)
+    url_name="treatment_search",
+)
 
 treatment_creation_wizard = wizards.TreatmentWizard.as_view(
     treatment_wizard_steps,
     label=_("New treatment"),
-    url_name='treatment_creation',)
+    url_name="treatment_creation",
+)
 
 treatment_n1_wizard_steps = [
-    ('selecfind-treatment_creation_n1', forms.UpstreamFindFormSelection),
-    ('file-treatment_creation_n1', forms.TreatmentFormFileChoice),
-    ('basetreatment-treatment_creation_n1', forms.N1TreatmentForm),
-    ('resultingfind-treatment_creation_n1', forms.ResultingFindForm),
-    ('final-treatment_creation_n1', FinalForm)
+    ("selecfind-treatment_creation_n1", forms.UpstreamFindFormSelection),
+    ("file-treatment_creation_n1", forms.TreatmentFormFileChoice),
+    ("basetreatment-treatment_creation_n1", forms.N1TreatmentForm),
+    ("resultingfind-treatment_creation_n1", forms.ResultingFindForm),
+    ("final-treatment_creation_n1", FinalForm),
 ]
 
 treatment_creation_n1_wizard = wizards.TreatmentN1Wizard.as_view(
     treatment_n1_wizard_steps,
     label=_("New treatment"),
-    url_name='treatment_creation_n1',)
+    url_name="treatment_creation_n1",
+)
 
 treatment_1n_wizard_steps = [
-    ('selecfind-treatment_creation_1n', forms.SingleUpstreamFindFormSelection),
-    ('file-treatment_creation_1n', forms.TreatmentFormFileChoice),
-    ('basetreatment-treatment_creation_1n', forms.OneNTreatmentForm),
-    ('resultingfinds-treatment_creation_1n', forms.ResultingFindsForm),
-    ('final-treatment_creation_1n', FinalForm)
+    ("selecfind-treatment_creation_1n", forms.SingleUpstreamFindFormSelection),
+    ("file-treatment_creation_1n", forms.TreatmentFormFileChoice),
+    ("basetreatment-treatment_creation_1n", forms.OneNTreatmentForm),
+    ("resultingfinds-treatment_creation_1n", forms.ResultingFindsForm),
+    ("final-treatment_creation_1n", FinalForm),
 ]
 
 treatment_creation_1n_wizard = wizards.Treatment1NWizard.as_view(
     treatment_1n_wizard_steps,
     label=_("New treatment"),
-    url_name='treatment_creation_1n',)
+    url_name="treatment_creation_1n",
+)
 
 treatment_modification_wizard = wizards.TreatmentModificationWizard.as_view(
-    [('selec-treatment_modification', forms.TreatmentFormSelection),
-     ('file-treatment_modification', forms.TreatmentFormFileChoice),
-     ('basetreatment-treatment_modification', forms.TreatmentModifyForm),
-     ('final-treatment_modification', FinalForm)],
+    [
+        ("selec-treatment_modification", forms.TreatmentFormSelection),
+        ("file-treatment_modification", forms.TreatmentFormFileChoice),
+        ("basetreatment-treatment_modification", forms.TreatmentModifyForm),
+        ("final-treatment_modification", FinalForm),
+    ],
     label=_("Treatment modification"),
-    url_name='treatment_modification',
+    url_name="treatment_modification",
 )
 
 
 def treatment_modify(request, pk):
-    if not wizard_is_available(treatment_modification_wizard, request,
-                               models.Treatment, pk):
+    if not wizard_is_available(
+        treatment_modification_wizard, request, models.Treatment, pk
+    ):
         return HttpResponseRedirect("/")
     wizards.TreatmentModificationWizard.session_set_value(
-        request, 'selec-treatment_modification', 'pk', pk, reset=True)
-    return redirect(reverse(
-        'treatment_modification',
-        kwargs={'step': 'file-treatment_modification'}))
+        request, "selec-treatment_modification", "pk", pk, reset=True
+    )
+    return redirect(
+        reverse(
+            "treatment_modification", kwargs={"step": "file-treatment_modification"}
+        )
+    )
 
 
 def treatment_add(request, pks, treatment_file=None):
     treatment_creation_wizard(request)
     wizards.TreatmentWizard.session_set_value(
-        request, 'selecfind-treatment_creation',
-        'resulting_pk', pks, reset=True)
+        request, "selecfind-treatment_creation", "resulting_pk", pks, reset=True
+    )
     if treatment_file:
         wizards.TreatmentWizard.session_set_value(
-            request, 'file-treatment_creation', 'file', treatment_file.pk)
+            request, "file-treatment_creation", "file", treatment_file.pk
+        )
     else:
         wizards.TreatmentWizard.session_set_value(
-            request, 'file-treatment_creation', 'file', '')
+            request, "file-treatment_creation", "file", ""
+        )
     if treatment_file:
         in_charge = treatment_file.in_charge
         if not in_charge:
@@ -676,24 +716,29 @@ def treatment_add(request, pks, treatment_file=None):
             dct["location"] = locas[0]
         for k in dct:
             wizards.TreatmentWizard.session_set_value(
-                request, 'basetreatment-treatment_creation', k, dct[k])
-    return redirect(reverse(
-        'treatment_creation',
-        kwargs={'step': 'basetreatment-treatment_creation'}))
+                request, "basetreatment-treatment_creation", k, dct[k]
+            )
+    return redirect(
+        reverse(
+            "treatment_creation", kwargs={"step": "basetreatment-treatment_creation"}
+        )
+    )
 
 
 def divide_treatment_add(request, pks, treatment_file=None):
     treatment_creation_1n_wizard(request)
 
     wizards.Treatment1NWizard.session_set_value(
-        request, 'selecfind-treatment_creation_1n',
-        'resulting_pk', pks, reset=True)
+        request, "selecfind-treatment_creation_1n", "resulting_pk", pks, reset=True
+    )
     if treatment_file:
         wizards.Treatment1NWizard.session_set_value(
-            request, 'file-treatment_creation_1n', 'file', treatment_file.pk)
+            request, "file-treatment_creation_1n", "file", treatment_file.pk
+        )
     else:
         wizards.Treatment1NWizard.session_set_value(
-            request, 'file-treatment_creation_1n', 'file', '')
+            request, "file-treatment_creation_1n", "file", ""
+        )
     if treatment_file:
         in_charge = treatment_file.in_charge
         if not in_charge:
@@ -717,10 +762,14 @@ def divide_treatment_add(request, pks, treatment_file=None):
             dct["location"] = locas[0]
         for k in dct:
             wizards.Treatment1NWizard.session_set_value(
-                request, 'basetreatment-treatment_creation_1n', k, dct[k])
-    return redirect(reverse(
-        'treatment_creation_1n',
-        kwargs={'step': 'basetreatment-treatment_creation_1n'}))
+                request, "basetreatment-treatment_creation_1n", k, dct[k]
+            )
+    return redirect(
+        reverse(
+            "treatment_creation_1n",
+            kwargs={"step": "basetreatment-treatment_creation_1n"},
+        )
+    )
 
 
 def find_treatment_add(request, pk, current_right=None):
@@ -774,86 +823,111 @@ def treatmentfile_treatment_add(request, pk, current_right=None):
     )
 
 
-treatment_deletion_wizard = wizards.TreatmentDeletionWizard.as_view([
-    ('selec-treatment_deletion', forms.TreatmentFormSelection),
-    ('final-treatment_deletion', forms.TreatmentDeletionForm)],
+treatment_deletion_wizard = wizards.TreatmentDeletionWizard.as_view(
+    [
+        ("selec-treatment_deletion", forms.TreatmentFormSelection),
+        ("final-treatment_deletion", forms.TreatmentDeletionForm),
+    ],
     label=_("Treatment deletion"),
-    url_name='treatment_deletion',)
+    url_name="treatment_deletion",
+)
 
 
 def treatment_delete(request, pk):
-    if not wizard_is_available(treatment_deletion_wizard, request,
-                               models.Treatment, pk):
+    if not wizard_is_available(
+        treatment_deletion_wizard, request, models.Treatment, pk
+    ):
         return HttpResponseRedirect("/")
     wizards.TreatmentDeletionWizard.session_set_value(
-        request, 'selec-treatment_deletion', 'pk', pk, reset=True)
-    return redirect(reverse(
-        'treatment_deletion',
-        kwargs={'step': 'final-treatment_deletion'}))
-
-
-treatment_administrativeact_search_wizard = \
-    wizards.SearchWizard.as_view([
-        ('selec-treatment_admacttreatment_search',
-         forms.AdministrativeActTreatmentFormSelection)],
-        label=_("Treatment: search administrative act"),
-        url_name='treatment_admacttreatment_search',)
-
-treatment_administrativeact_wizard = \
-    wizards.TreatmentAdministrativeActWizard.as_view([
-        ('selec-treatment_admacttreatment', forms.TreatmentFormSelection),
-        ('administrativeact-treatment_admacttreatment',
-         forms.AdministrativeActTreatmentForm),
-        ('final-treatment_admacttreatment', FinalForm)],
-        label=_("Treatment: new administrative act"),
-        url_name='treatment_admacttreatment',)
-
-treatment_administrativeact_modification_wizard = \
-    wizards.TreatmentEditAdministrativeActWizard.as_view([
-        ('selec-treatment_admacttreatment_modification',
-         forms.AdministrativeActTreatmentFormSelection),
-        ('administrativeact-treatment_admacttreatment_modification',
-         forms.AdministrativeActTreatmentModifForm),
-        ('final-treatment_admacttreatment_modification', FinalForm)],
+        request, "selec-treatment_deletion", "pk", pk, reset=True
+    )
+    return redirect(
+        reverse("treatment_deletion", kwargs={"step": "final-treatment_deletion"})
+    )
+
+
+treatment_administrativeact_search_wizard = wizards.SearchWizard.as_view(
+    [
+        (
+            "selec-treatment_admacttreatment_search",
+            forms.AdministrativeActTreatmentFormSelection,
+        )
+    ],
+    label=_("Treatment: search administrative act"),
+    url_name="treatment_admacttreatment_search",
+)
+
+treatment_administrativeact_wizard = wizards.TreatmentAdministrativeActWizard.as_view(
+    [
+        ("selec-treatment_admacttreatment", forms.TreatmentFormSelection),
+        (
+            "administrativeact-treatment_admacttreatment",
+            forms.AdministrativeActTreatmentForm,
+        ),
+        ("final-treatment_admacttreatment", FinalForm),
+    ],
+    label=_("Treatment: new administrative act"),
+    url_name="treatment_admacttreatment",
+)
+
+treatment_administrativeact_modification_wizard = (
+    wizards.TreatmentEditAdministrativeActWizard.as_view(
+        [
+            (
+                "selec-treatment_admacttreatment_modification",
+                forms.AdministrativeActTreatmentFormSelection,
+            ),
+            (
+                "administrativeact-treatment_admacttreatment_modification",
+                forms.AdministrativeActTreatmentModifForm,
+            ),
+            ("final-treatment_admacttreatment_modification", FinalForm),
+        ],
         label=_("Treatment: administrative act modification"),
-        url_name='treatment_admacttreatment_modification',)
+        url_name="treatment_admacttreatment_modification",
+    )
+)
 
 
 def treatment_administrativeacttreatment_modify(request, pk):
-    if not wizard_is_available(treatment_administrativeact_modification_wizard,
-                               request, AdministrativeAct, pk):
+    if not wizard_is_available(
+        treatment_administrativeact_modification_wizard, request, AdministrativeAct, pk
+    ):
         return HttpResponseRedirect("/")
     wizards.TreatmentEditAdministrativeActWizard.session_set_value(
-        request,
-        'selec-treatment_admacttreatment_modification',
-        'pk', pk, reset=True)
+        request, "selec-treatment_admacttreatment_modification", "pk", pk, reset=True
+    )
     return redirect(
         reverse(
-            'treatment_admacttreatment_modification',
-            kwargs={
-                'step':
-                    'administrativeact-treatment_admacttreatment_modification'
-            }))
-
-treatment_admacttreatment_deletion_wizard = \
-    AdministrativeActDeletionWizard.as_view([
-        ('selec-treatment_admacttreatment_deletion',
-         forms.AdministrativeActTreatmentFormSelection),
-        ('final-treatment_admacttreatment_deletion',
-         FinalAdministrativeActDeleteForm)],
-        label=_("Treatment: administrative act deletion"),
-        url_name='treatment_admacttreatment_deletion',)
+            "treatment_admacttreatment_modification",
+            kwargs={"step": "administrativeact-treatment_admacttreatment_modification"},
+        )
+    )
+
+
+treatment_admacttreatment_deletion_wizard = AdministrativeActDeletionWizard.as_view(
+    [
+        (
+            "selec-treatment_admacttreatment_deletion",
+            forms.AdministrativeActTreatmentFormSelection,
+        ),
+        ("final-treatment_admacttreatment_deletion", FinalAdministrativeActDeleteForm),
+    ],
+    label=_("Treatment: administrative act deletion"),
+    url_name="treatment_admacttreatment_deletion",
+)
 
 
 def treatment_administrativeacttreatment_delete(request, pk):
-    if not wizard_is_available(treatment_admacttreatment_deletion_wizard,
-                               request, AdministrativeAct, pk):
+    if not wizard_is_available(
+        treatment_admacttreatment_deletion_wizard, request, AdministrativeAct, pk
+    ):
         return HttpResponseRedirect("/")
     wizard_url = "treatment_admacttreatment_deletion"
     AdministrativeActDeletionWizard.session_set_value(
-        request, 'selec-' + wizard_url, 'pk', pk, reset=True)
-    return redirect(
-        reverse(wizard_url, kwargs={'step': 'final-' + wizard_url}))
+        request, "selec-" + wizard_url, "pk", pk, reset=True
+    )
+    return redirect(reverse(wizard_url, kwargs={"step": "final-" + wizard_url}))
 
 
 def treatment_adminact_add(request, pk, current_right=None):
@@ -864,125 +938,169 @@ def treatment_adminact_add(request, pk, current_right=None):
     treatment_administrativeact_wizard(request)
 
     wizards.TreatmentAdministrativeActWizard.session_set_value(
-        request, 'selec-treatment_admacttreatment', 'pk', pk, reset=True)
-    return redirect(reverse(
-        'treatment_admacttreatment',
-        kwargs={'step': 'administrativeact-treatment_admacttreatment'}))
+        request, "selec-treatment_admacttreatment", "pk", pk, reset=True
+    )
+    return redirect(
+        reverse(
+            "treatment_admacttreatment",
+            kwargs={"step": "administrativeact-treatment_admacttreatment"},
+        )
+    )
 
 
 # treatment request
 
-treatmentfile_search_wizard = wizards.TreatmentFileSearch.as_view([
-    ('general-treatmentfile_search', forms.TreatmentFileFormSelection)],
+treatmentfile_search_wizard = wizards.TreatmentFileSearch.as_view(
+    [("general-treatmentfile_search", forms.TreatmentFileFormSelection)],
     label=_("Treatment request search"),
-    url_name='treatmentfile_search',)
+    url_name="treatmentfile_search",
+)
 
 treatmentfile_wizard_steps = [
-    ('treatmentfile-treatmentfile_creation', forms.TreatmentFileForm),
-    ('final-treatmentfile_creation', FinalForm)]
+    ("treatmentfile-treatmentfile_creation", forms.TreatmentFileForm),
+    ("final-treatmentfile_creation", FinalForm),
+]
 
 
 treatmentfile_creation_wizard = wizards.TreatmentFileWizard.as_view(
     treatmentfile_wizard_steps,
     label=_("New treatment request"),
-    url_name='treatmentfile_creation',)
-
-treatmentfile_modification_wizard = \
-    wizards.TreatmentFileModificationWizard.as_view(
-        [('selec-treatmentfile_modification', forms.TreatmentFileFormSelection),
-         ('treatmentfile-treatmentfile_modification',
-          forms.TreatmentFileModifyForm),
-         ('final-treatmentfile_modification', FinalForm)],
-        label=_("Treatment request modification"),
-        url_name='treatmentfile_modification',
-    )
+    url_name="treatmentfile_creation",
+)
+
+treatmentfile_modification_wizard = wizards.TreatmentFileModificationWizard.as_view(
+    [
+        ("selec-treatmentfile_modification", forms.TreatmentFileFormSelection),
+        ("treatmentfile-treatmentfile_modification", forms.TreatmentFileModifyForm),
+        ("final-treatmentfile_modification", FinalForm),
+    ],
+    label=_("Treatment request modification"),
+    url_name="treatmentfile_modification",
+)
 
 
 def treatmentfile_modify(request, pk):
-    if not wizard_is_available(treatmentfile_modification_wizard, request,
-                               models.TreatmentFile, pk):
+    if not wizard_is_available(
+        treatmentfile_modification_wizard, request, models.TreatmentFile, pk
+    ):
         return HttpResponseRedirect("/")
     wizards.TreatmentFileModificationWizard.session_set_value(
-        request, 'selec-treatmentfile_modification', 'pk', pk, reset=True)
-    return redirect(reverse(
-        'treatmentfile_modification',
-        kwargs={'step': 'treatmentfile-treatmentfile_modification'}))
+        request, "selec-treatmentfile_modification", "pk", pk, reset=True
+    )
+    return redirect(
+        reverse(
+            "treatmentfile_modification",
+            kwargs={"step": "treatmentfile-treatmentfile_modification"},
+        )
+    )
 
 
 def treatmentfile_add(request, basket_pk=None):
     treatmentfile_creation_wizard(request)
     wizards.TreatmentFileWizard.session_set_value(
-        request, 'treatmentfile-treatmentfile_creation',
-        'associated_basket', basket_pk, reset=True)
-    url = reverse('treatmentfile_creation',
-                  kwargs={'step': 'treatmentfile-treatmentfile_creation'})
+        request,
+        "treatmentfile-treatmentfile_creation",
+        "associated_basket",
+        basket_pk,
+        reset=True,
+    )
+    url = reverse(
+        "treatmentfile_creation",
+        kwargs={"step": "treatmentfile-treatmentfile_creation"},
+    )
     url += "?associated_basket={}".format(basket_pk)
     return redirect(url)
 
 
-treatmentfile_deletion_wizard = wizards.TreatmentFileDeletionWizard.as_view([
-    ('selec-treatmentfile_deletion', forms.TreatmentFileFormSelectionMultiple),
-    ('final-treatmentfile_deletion', forms.TreatmentFileDeletionForm)],
+treatmentfile_deletion_wizard = wizards.TreatmentFileDeletionWizard.as_view(
+    [
+        ("selec-treatmentfile_deletion", forms.TreatmentFileFormSelectionMultiple),
+        ("final-treatmentfile_deletion", forms.TreatmentFileDeletionForm),
+    ],
     label=_("Treatment request deletion"),
-    url_name='treatmentfile_deletion',)
+    url_name="treatmentfile_deletion",
+)
 
 
 def treatmentfile_delete(request, pk):
-    if not wizard_is_available(treatmentfile_deletion_wizard,
-                               request, models.TreatmentFile, pk):
+    if not wizard_is_available(
+        treatmentfile_deletion_wizard, request, models.TreatmentFile, pk
+    ):
         return HttpResponseRedirect("/")
     wizard_url = "treatmentfile_deletion"
     wizards.TreatmentFileDeletionWizard.session_set_value(
-        request, 'selec-' + wizard_url, 'pks', pk, reset=True)
-    return redirect(
-        reverse(wizard_url, kwargs={'step': 'final-' + wizard_url}))
+        request, "selec-" + wizard_url, "pks", pk, reset=True
+    )
+    return redirect(reverse(wizard_url, kwargs={"step": "final-" + wizard_url}))
 
 
-treatmentfile_admacttreatmentfile_search_wizard = \
-    wizards.SearchWizard.as_view([
-        ('selec-treatmentfle_admacttreatmentfle_search',
-         forms.AdministrativeActTreatmentFileFormSelection)],
-        label=_("Treatment request: search administrative act"),
-        url_name='treatmentfle_admacttreatmentfle_search',)
+treatmentfile_admacttreatmentfile_search_wizard = wizards.SearchWizard.as_view(
+    [
+        (
+            "selec-treatmentfle_admacttreatmentfle_search",
+            forms.AdministrativeActTreatmentFileFormSelection,
+        )
+    ],
+    label=_("Treatment request: search administrative act"),
+    url_name="treatmentfle_admacttreatmentfle_search",
+)
 
 
-treatmentfile_admacttreatmentfile_wizard = \
-    wizards.TreatmentFileAdministrativeActWizard.as_view([
-        ('selec-treatmentfle_admacttreatmentfle',
-         forms.TreatmentFileFormSelection),
-        ('admact-treatmentfle_admacttreatmentfle',
-         forms.AdministrativeActTreatmentFileForm),
-        ('final-treatmentfle_admacttreatmentfle', FinalForm)],
+treatmentfile_admacttreatmentfile_wizard = (
+    wizards.TreatmentFileAdministrativeActWizard.as_view(
+        [
+            ("selec-treatmentfle_admacttreatmentfle", forms.TreatmentFileFormSelection),
+            (
+                "admact-treatmentfle_admacttreatmentfle",
+                forms.AdministrativeActTreatmentFileForm,
+            ),
+            ("final-treatmentfle_admacttreatmentfle", FinalForm),
+        ],
         label=_("Treatment request: new administrative act"),
-        url_name='treatmentfle_admacttreatmentfle',)
-
-treatmentfile_admacttreatmentfile_modification_wizard = \
-    wizards.TreatmentFileEditAdministrativeActWizard.as_view([
-        ('selec-treatmentfle_admacttreatmentfle_modification',
-         forms.AdministrativeActTreatmentFileFormSelection),
-        ('admact-treatmentfle_admacttreatmentfle_modification',
-         forms.AdministrativeActTreatmentFileModifForm),
-        ('final-treatmentfle_admacttreatmentfle_modification', FinalForm)],
+        url_name="treatmentfle_admacttreatmentfle",
+    )
+)
+
+treatmentfile_admacttreatmentfile_modification_wizard = (
+    wizards.TreatmentFileEditAdministrativeActWizard.as_view(
+        [
+            (
+                "selec-treatmentfle_admacttreatmentfle_modification",
+                forms.AdministrativeActTreatmentFileFormSelection,
+            ),
+            (
+                "admact-treatmentfle_admacttreatmentfle_modification",
+                forms.AdministrativeActTreatmentFileModifForm,
+            ),
+            ("final-treatmentfle_admacttreatmentfle_modification", FinalForm),
+        ],
         label=_("Treatment request: administrative act modification"),
-        url_name='treatmentfle_admacttreatmentfle_modification',)
+        url_name="treatmentfle_admacttreatmentfle_modification",
+    )
+)
 
 
 def treatmentfile_administrativeacttreatmentfile_modify(request, pk):
     if not wizard_is_available(
-            treatmentfile_admacttreatmentfile_modification_wizard,
-            request, AdministrativeAct, pk):
+        treatmentfile_admacttreatmentfile_modification_wizard,
+        request,
+        AdministrativeAct,
+        pk,
+    ):
         return HttpResponseRedirect("/")
     wizards.TreatmentFileEditAdministrativeActWizard.session_set_value(
         request,
-        'selec-treatmentfle_admacttreatmentfle_modification',
-        'pk', pk, reset=True)
+        "selec-treatmentfle_admacttreatmentfle_modification",
+        "pk",
+        pk,
+        reset=True,
+    )
     return redirect(
         reverse(
-            'treatmentfle_admacttreatmentfle_modification',
-            kwargs={
-                'step':
-                    'admact-treatmentfle_admacttreatmentfle_modification'
-            }))
+            "treatmentfle_admacttreatmentfle_modification",
+            kwargs={"step": "admact-treatmentfle_admacttreatmentfle_modification"},
+        )
+    )
 
 
 def treatmentfile_adminact_add(request, pk, current_right=None):
@@ -993,59 +1111,75 @@ def treatmentfile_adminact_add(request, pk, current_right=None):
     treatmentfile_admacttreatmentfile_wizard(request)
 
     wizards.TreatmentFileAdministrativeActWizard.session_set_value(
-        request, 'selec-treatmentfle_admacttreatmentfle', 'pk', pk, reset=True)
-    return redirect(reverse(
-        'treatmentfle_admacttreatmentfle',
-        kwargs={'step': 'admact-treatmentfle_admacttreatmentfle'}))
-
-
-treatmentfile_admacttreatmentfile_deletion_wizard = \
-    AdministrativeActDeletionWizard.as_view([
-        ('selec-treatmentfle_admacttreatmentfle_deletion',
-         forms.AdministrativeActTreatmentFileFormSelection),
-        ('final-treatmentfle_admacttreatmentfle_deletion',
-         FinalAdministrativeActDeleteForm)],
+        request, "selec-treatmentfle_admacttreatmentfle", "pk", pk, reset=True
+    )
+    return redirect(
+        reverse(
+            "treatmentfle_admacttreatmentfle",
+            kwargs={"step": "admact-treatmentfle_admacttreatmentfle"},
+        )
+    )
+
+
+treatmentfile_admacttreatmentfile_deletion_wizard = (
+    AdministrativeActDeletionWizard.as_view(
+        [
+            (
+                "selec-treatmentfle_admacttreatmentfle_deletion",
+                forms.AdministrativeActTreatmentFileFormSelection,
+            ),
+            (
+                "final-treatmentfle_admacttreatmentfle_deletion",
+                FinalAdministrativeActDeleteForm,
+            ),
+        ],
         label=_("Treatment request: administrative act deletion"),
-        url_name='treatmentfle_admacttreatmentfle_deletion',)
+        url_name="treatmentfle_admacttreatmentfle_deletion",
+    )
+)
 
 
 def treatmentfile_administrativeacttreatmentfile_delete(request, pk):
     if not wizard_is_available(
-            treatmentfile_admacttreatmentfile_deletion_wizard, request,
-            AdministrativeAct, pk):
+        treatmentfile_admacttreatmentfile_deletion_wizard,
+        request,
+        AdministrativeAct,
+        pk,
+    ):
         return HttpResponseRedirect("/")
     wizard_url = "treatmentfle_admacttreatmentfle_deletion"
     AdministrativeActDeletionWizard.session_set_value(
-        request, 'selec-' + wizard_url, 'pk', pk, reset=True)
-    return redirect(
-        reverse(wizard_url, kwargs={'step': 'final-' + wizard_url}))
+        request, "selec-" + wizard_url, "pk", pk, reset=True
+    )
+    return redirect(reverse(wizard_url, kwargs={"step": "final-" + wizard_url}))
 
 
 def reset_wizards(request):
     for wizard_class, url_name in (
-            (wizards.FindWizard, 'find_creation'),
-            (wizards.FindModificationWizard, 'find_modification'),
-            (wizards.FindDeletionWizard, 'find_deletion'),
-            (wizards.TreatmentWizard, 'treatement_creation'),
-            (wizards.TreatmentModificationWizard, 'treatment_modification'),
-            (wizards.TreatmentDeletionWizard, 'treatment_deletion'),
-            (wizards.TreatmentAdministrativeActWizard,
-             'treatment_admacttreatment'),
-            (wizards.TreatmentEditAdministrativeActWizard,
-             'treatment_admacttreatment_modification'),
-            (wizards.TreatmentDeletionWizard,
-             'treatment_admacttreatment_deletion'),
-            (wizards.TreatmentFileWizard,
-             'treatmentfile_creation'),
-            (wizards.TreatmentFileModificationWizard,
-             'treatmentfile_modification'),
-            (wizards.TreatmentFileDeletionWizard, 'treatmentfile_deletion'),
-            (wizards.TreatmentFileAdministrativeActWizard,
-             'treatmentfle_admacttreatmentfle'),
-            (wizards.TreatmentFileEditAdministrativeActWizard,
-             'treatmentfle_admacttreatmentfle_modification'),
-            (AdministrativeActDeletionWizard,
-             'treatmentfle_admacttreatmentfle_deletion'),
+        (wizards.FindWizard, "find_creation"),
+        (wizards.FindModificationWizard, "find_modification"),
+        (wizards.FindDeletionWizard, "find_deletion"),
+        (wizards.TreatmentWizard, "treatement_creation"),
+        (wizards.TreatmentModificationWizard, "treatment_modification"),
+        (wizards.TreatmentDeletionWizard, "treatment_deletion"),
+        (wizards.TreatmentAdministrativeActWizard, "treatment_admacttreatment"),
+        (
+            wizards.TreatmentEditAdministrativeActWizard,
+            "treatment_admacttreatment_modification",
+        ),
+        (wizards.TreatmentDeletionWizard, "treatment_admacttreatment_deletion"),
+        (wizards.TreatmentFileWizard, "treatmentfile_creation"),
+        (wizards.TreatmentFileModificationWizard, "treatmentfile_modification"),
+        (wizards.TreatmentFileDeletionWizard, "treatmentfile_deletion"),
+        (
+            wizards.TreatmentFileAdministrativeActWizard,
+            "treatmentfle_admacttreatmentfle",
+        ),
+        (
+            wizards.TreatmentFileEditAdministrativeActWizard,
+            "treatmentfle_admacttreatmentfle_modification",
+        ),
+        (AdministrativeActDeletionWizard, "treatmentfle_admacttreatmentfle_deletion"),
     ):
         wizard_class.session_reset(request, url_name)
 
@@ -1053,11 +1187,11 @@ def reset_wizards(request):
 class QAFindForm(QAItemEditForm):
     model = models.Find
     form_class = forms.QAFindFormMulti
-    template_name = 'ishtar/forms/qa_find_edit_form.html'
+    template_name = "ishtar/forms/qa_find_edit_form.html"
 
 
 class QAFindBasketFormView(QAItemForm):
-    template_name = 'ishtar/forms/qa_find_basket.html'
+    template_name = "ishtar/forms/qa_find_basket.html"
     model = models.Find
     form_class = forms.QAFindBasketForm
     page_name = _("Basket")
@@ -1066,7 +1200,7 @@ class QAFindBasketFormView(QAItemForm):
 
     def get_form_kwargs(self):
         kwargs = super(QAFindBasketFormView, self).get_form_kwargs()
-        kwargs['user'] = self.request.user
+        kwargs["user"] = self.request.user
         return kwargs
 
     def form_valid(self, form):
@@ -1075,7 +1209,7 @@ class QAFindBasketFormView(QAItemForm):
 
 
 class QAFindDuplicateFormView(QAItemForm):
-    template_name = 'ishtar/forms/qa_find_duplicate.html'
+    template_name = "ishtar/forms/qa_find_duplicate.html"
     model = models.Find
     page_name = _("Duplicate")
     form_class = forms.QAFindDuplicateForm
@@ -1083,7 +1217,7 @@ class QAFindDuplicateFormView(QAItemForm):
 
     def get_form_kwargs(self):
         kwargs = super(QAFindDuplicateFormView, self).get_form_kwargs()
-        kwargs['user'] = self.request.user
+        kwargs["user"] = self.request.user
         return kwargs
 
     def form_valid(self, form):
@@ -1091,18 +1225,17 @@ class QAFindDuplicateFormView(QAItemForm):
         return HttpResponseRedirect(reverse("success"))
 
     def get_context_data(self, **kwargs):
-        data = super(QAFindDuplicateFormView, self).get_context_data(
-            **kwargs)
-        data['action_name'] = _("Duplicate")
+        data = super(QAFindDuplicateFormView, self).get_context_data(**kwargs)
+        data["action_name"] = _("Duplicate")
         bf = self.items[0].get_first_base_find()
         if bf:
-            data['context_record'] = bf.context_record
-            data['operation'] = bf.context_record.operation
+            data["context_record"] = bf.context_record
+            data["operation"] = bf.context_record.operation
         return data
 
 
 class QAFindTreatmentFormView(QAItemForm):
-    template_name = 'ishtar/forms/qa_find_treatment.html'
+    template_name = "ishtar/forms/qa_find_treatment.html"
     model = models.Find
     form_class = forms.QAFindTreatmentForm
     page_name = _("Packaging")
@@ -1110,7 +1243,8 @@ class QAFindTreatmentFormView(QAItemForm):
 
     def dispatch(self, request, *args, **kwargs):
         returned = super(QAFindTreatmentFormView, self).dispatch(
-            request, *args, **kwargs)
+            request, *args, **kwargs
+        )
         for item in self.items:
             if item.is_locked(request.user):
                 return HttpResponseRedirect(reverse("qa-not-available"))
@@ -1118,8 +1252,8 @@ class QAFindTreatmentFormView(QAItemForm):
 
     def get_form_kwargs(self):
         kwargs = super(QAFindTreatmentFormView, self).get_form_kwargs()
-        kwargs['user'] = self.request.user
-        kwargs['prefix'] = "qa-packaging"
+        kwargs["user"] = self.request.user
+        kwargs["prefix"] = "qa-packaging"
         return kwargs
 
     def form_valid(self, form):
@@ -1128,7 +1262,7 @@ class QAFindTreatmentFormView(QAItemForm):
 
 
 class QAFindbasketDuplicateFormView(QAItemForm):
-    template_name = 'ishtar/forms/qa_findbasket_duplicate.html'
+    template_name = "ishtar/forms/qa_findbasket_duplicate.html"
     model = models.FindBasket
     page_name = _("Duplicate")
     modal_size = "small"
@@ -1137,7 +1271,7 @@ class QAFindbasketDuplicateFormView(QAItemForm):
 
     def get_form_kwargs(self):
         kwargs = super(QAFindbasketDuplicateFormView, self).get_form_kwargs()
-        kwargs['user'] = self.request.user
+        kwargs["user"] = self.request.user
         return kwargs
 
     def form_valid(self, form):
@@ -1145,9 +1279,8 @@ class QAFindbasketDuplicateFormView(QAItemForm):
         return HttpResponseRedirect(reverse("success"))
 
     def get_context_data(self, **kwargs):
-        data = super(QAFindbasketDuplicateFormView, self).get_context_data(
-            **kwargs)
-        data['action_name'] = _("Duplicate")
+        data = super(QAFindbasketDuplicateFormView, self).get_context_data(**kwargs)
+        data["action_name"] = _("Duplicate")
         return data
 
 
@@ -1166,22 +1299,24 @@ class PublicFindAPI(APIView):
         if not basket_slug:
             return empty
         try:
-            basket = models.FindBasket.objects.get(
-                slug=basket_slug, public=True)
+            basket = models.FindBasket.objects.get(slug=basket_slug, public=True)
         except models.FindBasket.DoesNotExist:
             return empty
-        q = models.FindBasket.items.through.objects.filter(
-            findbasket_id=basket.id).values("find_id").order_by("id")
+        q = (
+            models.FindBasket.items.through.objects.filter(findbasket_id=basket.id)
+            .values("find_id")
+            .order_by("id")
+        )
         id_list = [bi["find_id"] for bi in q]
-        clauses = ' '.join(
-            'WHEN id=%s THEN %s' % (pk, i) for i, pk in enumerate(id_list)
+        clauses = " ".join(
+            "WHEN id=%s THEN %s" % (pk, i) for i, pk in enumerate(id_list)
         )
 
-        ordering = 'CASE {} END'.format(clauses)
+        ordering = "CASE {} END".format(clauses)
         return models.Find.objects.filter(id__in=id_list).extra(
-           select={'ordering': ordering}, order_by=('ordering',))
+            select={"ordering": ordering}, order_by=("ordering",)
+        )
 
     def get(self, request, format=None):
         serializer = PublicSerializer(self.get_queryset(), many=True)
         return Response(serializer.data)
-