Format - black: ishtar_common

1 files changed, 270 insertions, 223 deletions

diff --git a/ishtar_common/forms.py b/ishtar_common/forms.py
index db627789f..f5ddee48e 100644
--- a/ishtar_common/forms.py
+++ b/ishtar_common/forms.py
@@ -49,7 +49,7 @@ from ishtar_common.utils import MultiValueDict
 
 
 class NamedUrlSessionFormWizard(forms.Form):
-    def __init__(self, form_list, condition_list=None, url_name=''):
+    def __init__(self, form_list, condition_list=None, url_name=""):
         if not condition_list:
             condition_list = {}
         self.form_list = dict(form_list)
@@ -65,14 +65,14 @@ def my_reverse(*args, **kwargs):
     """
     Custom reverse method in order to evaluate lazy args
     """
-    if 'args' in kwargs:
+    if "args" in kwargs:
         my_args = []
-        for arg in kwargs['args']:
+        for arg in kwargs["args"]:
             if callable(arg):
                 my_args.append(str(arg()))
             else:
                 my_args.append(str(arg))
-        kwargs['args'] = my_args
+        kwargs["args"] = my_args
     return reverse(*args, **kwargs)
 
 
@@ -82,14 +82,15 @@ regexp_name = re.compile(r"^[\.,:/\w\-'\"() \&\[\]@]+$", re.UNICODE)
 name_validator = validators.RegexValidator(
     regexp_name,
     _("Enter a valid name consisting of letters, spaces and hyphens."),
-    'invalid')
+    "invalid",
+)
 
 
 def file_size_validator(value):
     limit = (settings.MAX_UPLOAD_SIZE * 1024 * 1024) - 100
     if value.size > limit:
         raise ValidationError(
-            str(_('File too large. Size should not exceed {} Mo.')).format(
+            str(_("File too large. Size should not exceed {} Mo.")).format(
                 settings.MAX_UPLOAD_SIZE
             )
         )
@@ -99,9 +100,10 @@ class FloatField(forms.FloatField):
     """
     Allow the use of comma for separating float fields
     """
+
     def clean(self, value):
         if value and isinstance(value, str):
-            value = value.replace(',', '.').replace('%', '')
+            value = value.replace(",", ".").replace("%", "")
         return super(FloatField, self).clean(value)
 
 
@@ -117,22 +119,23 @@ class FinalDeleteForm(FinalForm):
 
 def get_readonly_clean(key):
     def func(self):
-        instance = getattr(self, 'instance', None)
+        instance = getattr(self, "instance", None)
         if instance and getattr(instance, key):
             return getattr(instance, key)
         else:
             return self.cleaned_data[key]
+
     return func
 
 
 JSON_VALUE_TYPES_FIELDS = {
-    'T': (forms.CharField, None),
-    'LT': (forms.CharField, forms.Textarea),
-    'I': (forms.IntegerField, None),
-    'F': (FloatField, None),
-    'D': (DateField, None),
-    'B': (forms.NullBooleanField, None),
-    'C': (widgets.Select2DynamicField, None),
+    "T": (forms.CharField, None),
+    "LT": (forms.CharField, forms.Textarea),
+    "I": (forms.IntegerField, None),
+    "F": (FloatField, None),
+    "D": (DateField, None),
+    "B": (forms.NullBooleanField, None),
+    "C": (widgets.Select2DynamicField, None),
 }
 
 
@@ -141,14 +144,14 @@ class BSForm(object):
         for k in self.fields:
             widget = self.fields[k].widget
             # manage bs decoration
-            if not hasattr(widget, 'NO_FORM_CONTROL'):
-                cls = 'form-control'
-                if 'class' in widget.attrs:
-                    if 'form-control' in widget.attrs['class']:
-                        cls = widget.attrs['class']
+            if not hasattr(widget, "NO_FORM_CONTROL"):
+                cls = "form-control"
+                if "class" in widget.attrs:
+                    if "form-control" in widget.attrs["class"]:
+                        cls = widget.attrs["class"]
                     else:
-                        cls = widget.attrs['class'] + " " + cls
-                widget.attrs['class'] = cls
+                        cls = widget.attrs["class"] + " " + cls
+                widget.attrs["class"] = cls
             # 32 bits max value
             if isinstance(self.fields[k], forms.IntegerField):
                 has_max = any(
@@ -158,17 +161,18 @@ class BSForm(object):
 
                 if not has_max:
                     self.fields[k].validators.append(
-                        validators.MaxValueValidator(2147483647))
+                        validators.MaxValueValidator(2147483647)
+                    )
             # manage datepicker
             if not isinstance(widget, DatePicker):
                 continue
             lang = translation.get_language()
-            widget.options['language'] = lang
+            widget.options["language"] = lang
             if lang in DATE_FORMAT:
-                widget.options['format'] = DATE_FORMAT[lang]
-            if 'autoclose' not in widget.options:
-                widget.options['autoclose'] = 'true'
-            widget.options['todayHighlight'] = 'true'
+                widget.options["format"] = DATE_FORMAT[lang]
+            if "autoclose" not in widget.options:
+                widget.options["autoclose"] = "true"
+            widget.options["todayHighlight"] = "true"
 
 
 class CustomForm(BSForm):
@@ -179,9 +183,9 @@ class CustomForm(BSForm):
 
     def __init__(self, *args, **kwargs):
         self.current_user = None
-        if 'user' in kwargs:
+        if "user" in kwargs:
             try:
-                self.current_user = kwargs.pop('user').ishtaruser
+                self.current_user = kwargs.pop("user").ishtaruser
             except AttributeError:
                 pass
         super(CustomForm, self).__init__(*args, **kwargs)
@@ -189,10 +193,9 @@ class CustomForm(BSForm):
             self.custom_form_ordering()
 
     def custom_form_ordering(self):
-        available, excluded, json_fields = self.check_custom_form(
-            self.current_user)
+        available, excluded, json_fields = self.check_custom_form(self.current_user)
         for exc in excluded:
-            if hasattr(self, 'fields'):
+            if hasattr(self, "fields"):
                 self.remove_field(exc)
             else:
                 # formset
@@ -206,12 +209,12 @@ class CustomForm(BSForm):
                 order += 1
             new_fields[order] = (key, field)
 
-        if not hasattr(self, 'fields'):  # formset
+        if not hasattr(self, "fields"):  # formset
             return
 
         field_items, field_hidden_items = [], []
         for key, field in self.fields.items():
-            if getattr(field.widget, 'is_hidden', None):
+            if getattr(field.widget, "is_hidden", None):
                 field_hidden_items.append((key, field))
             else:
                 field_items.append((key, field))
@@ -260,10 +263,10 @@ class CustomForm(BSForm):
         :param key: data key
         :return: tuple of choices (id, value)
         """
-        app_name = cls.__module__.split('.')[0]
+        app_name = cls.__module__.split(".")[0]
         if app_name == "archaeological_files_pdl":
             app_name = "archaeological_files"
-        model_name = cls.form_slug.split("-")[0].replace('_', "")
+        model_name = cls.form_slug.split("-")[0].replace("_", "")
         ct_class = apps.get_model(app_name, model_name)
         return ct_class._get_dynamic_choices(key)
 
@@ -277,31 +280,38 @@ class CustomForm(BSForm):
         fields = []
         is_search = "search_vector" in cls.base_fields
         q = custom_form.json_fields.values(
-            'label', 'help_text', 'order', 'json_field__key',
-            'json_field__value_type', 'json_field__name',
-        ).order_by('order')
+            "label",
+            "help_text",
+            "order",
+            "json_field__key",
+            "json_field__value_type",
+            "json_field__name",
+        ).order_by("order")
         for field in q.all():
-            key = "data__" + field['json_field__key']
+            key = "data__" + field["json_field__key"]
             field_cls, widget = forms.CharField, None
-            if field['json_field__value_type'] in JSON_VALUE_TYPES_FIELDS:
+            if field["json_field__value_type"] in JSON_VALUE_TYPES_FIELDS:
                 field_cls, widget = JSON_VALUE_TYPES_FIELDS[
-                    field['json_field__value_type']]
-                if is_search and field['json_field__value_type'] == "LT":
+                    field["json_field__value_type"]
+                ]
+                if is_search and field["json_field__value_type"] == "LT":
                     widget = None
-            attrs = {'label': field['label'] or field['json_field__name'],
-                     'required': False}
-            if field['help_text']:
-                attrs['help_text'] = field['help_text']
+            attrs = {
+                "label": field["label"] or field["json_field__name"],
+                "required": False,
+            }
+            if field["help_text"]:
+                attrs["help_text"] = field["help_text"]
             if widget:
-                attrs['widget'] = widget()
+                attrs["widget"] = widget()
             if field_cls == widgets.Select2DynamicField:
-                attrs['choices'] = cls._get_dynamic_choices(key)
+                attrs["choices"] = cls._get_dynamic_choices(key)
             f = field_cls(**attrs)
-            kls = 'form-control'
-            if 'class' in f.widget.attrs:
-                kls = f.widget.attrs['class'] + " " + kls
-            f.widget.attrs['class'] = kls
-            f.alt_name = slugify(attrs['label'])
+            kls = "form-control"
+            if "class" in f.widget.attrs:
+                kls = f.widget.attrs["class"] + " " + kls
+            f.widget.attrs["class"] = kls
+            f.alt_name = slugify(attrs["label"])
             fields.append((field["order"] or 1, key, f))
         return fields
 
@@ -314,26 +324,25 @@ class CustomForm(BSForm):
         """
         if not current_user:
             return True, [], []
-        base_q = {"form": cls.form_slug, 'available': True}
+        base_q = {"form": cls.form_slug, "available": True}
         # order is important : try for user, profile type, user type then all
         query_dicts = []
         if current_user:
             dct = base_q.copy()
-            dct.update({'users__pk': current_user.pk})
+            dct.update({"users__pk": current_user.pk})
             query_dicts = [dct]
             if current_user.current_profile:
                 dct = base_q.copy()
                 pt = current_user.current_profile.profile_type.pk
-                dct.update(
-                    {'profile_types__pk': pt})
+                dct.update({"profile_types__pk": pt})
                 query_dicts.append(dct)
 
             for user_type in current_user.person.person_types.all():
                 dct = base_q.copy()
-                dct.update({'user_types__pk': user_type.pk}),
+                dct.update({"user_types__pk": user_type.pk}),
                 query_dicts.append(dct)
         dct = base_q.copy()
-        dct.update({'apply_to_all': True})
+        dct.update({"apply_to_all": True})
         query_dicts.append(dct)
         form = None
         for query_dict in query_dicts:
@@ -360,7 +369,7 @@ class CustomForm(BSForm):
         Get fields than can be customized: excluded, re-ordered (WIP) or
         re-labeled (WIP)
         """
-        if hasattr(cls, 'base_fields'):
+        if hasattr(cls, "base_fields"):
             fields = cls.base_fields
         else:
             # formset
@@ -371,9 +380,12 @@ class CustomForm(BSForm):
             field = fields[key]
             # cannot customize display of required (except in search form) and
             # hidden field, search_vector and field with no label
-            if ('search_vector' not in keys and field.required) or \
-                    key == 'search_vector' or field.widget.is_hidden or \
-                    not field.label:
+            if (
+                ("search_vector" not in keys and field.required)
+                or key == "search_vector"
+                or field.widget.is_hidden
+                or not field.label
+            ):
                 continue
             customs.append((key, field.label))
         return sorted(customs, key=lambda x: x[1])
@@ -384,12 +396,12 @@ class CustomFormSearch(forms.Form):
 
     def __init__(self, *args, **kwargs):
         user = None
-        if 'user' in kwargs:
-            user = kwargs.pop('user')
+        if "user" in kwargs:
+            user = kwargs.pop("user")
         super(CustomFormSearch, self).__init__(*args, **kwargs)
         self.request_user = user
-        if user and 'pk' in self.fields:
-            self.fields['pk'].widget.user = user
+        if user and "pk" in self.fields:
+            self.fields["pk"].widget.user = user
 
 
 class LockForm(object):
@@ -416,25 +428,25 @@ class LockForm(object):
             except model.DoesNotExist:
                 raise forms.ValidationError(_("Invalid selection."))
             if item.is_locked(self.request_user):
-                raise forms.ValidationError(_("This item is locked "
-                                              "for edition."))
+                raise forms.ValidationError(_("This item is locked " "for edition."))
         return self.cleaned_data
 
 
 class MultiSearchForm(CustomFormSearch):
     SEARCH_AND_SELECT = True
-    pk_key = 'pks'
+    pk_key = "pks"
     associated_models = {}
 
     def __init__(self, *args, **kwargs):
         super(MultiSearchForm, self).__init__(*args, **kwargs)
         if "pk" not in self.fields:
-            raise NotImplementedError("A \"pk\" field must be defined")
+            raise NotImplementedError('A "pk" field must be defined')
         if self.pk_key not in self.associated_models:
-            raise NotImplementedError("\"{}\" must be defined in "
-                                      "associated_models".format(self.pk_key))
-        self.fields['pk'].required = True
-        self.fields[self.pk_key] = self.fields.pop('pk')
+            raise NotImplementedError(
+                '"{}" must be defined in ' "associated_models".format(self.pk_key)
+            )
+        self.fields["pk"].required = True
+        self.fields[self.pk_key] = self.fields.pop("pk")
 
     @classmethod
     def get_current_model(cls):
@@ -453,21 +465,20 @@ class MultiSearchForm(CustomFormSearch):
             if not data or cls.pk_key not in data or not data[cls.pk_key]:
                 continue
             pks = data[cls.pk_key]
-            for pk in str(pks).split(','):
+            for pk in str(pks).split(","):
                 if not pk:
                     continue
                 try:
-                    items.append(
-                        str(current_model.objects.get(pk=int(pk)))
-                    )
+                    items.append(str(current_model.objects.get(pk=int(pk))))
                 except (current_model.DoesNotExist, ValueError):
                     continue
         return [
-            ("",
-             mark_safe(
-                 "<ul class='compact'><li>" + "</li><li>".join(items) +
-                 "</li></ul>"
-             ))
+            (
+                "",
+                mark_safe(
+                    "<ul class='compact'><li>" + "</li><li>".join(items) + "</li></ul>"
+                ),
+            )
         ]
 
 
@@ -476,17 +487,18 @@ class FormSet(CustomForm, BaseFormSet):
 
     def __init__(self, *args, **kwargs):
         self.readonly = False
-        if 'readonly' in kwargs:
-            self.readonly = kwargs.pop('readonly')
+        if "readonly" in kwargs:
+            self.readonly = kwargs.pop("readonly")
             self.can_delete = False
             # no extra fields
-            if 'data' in kwargs:
+            if "data" in kwargs:
                 prefix = ""
                 if "prefix" in kwargs:
-                    prefix = kwargs['prefix']
-                if prefix + '-INITIAL_FORMS' in kwargs['data']:
-                    kwargs['data'][prefix + '-TOTAL_FORMS'] = \
-                        kwargs["data"][prefix + '-INITIAL_FORMS']
+                    prefix = kwargs["prefix"]
+                if prefix + "-INITIAL_FORMS" in kwargs["data"]:
+                    kwargs["data"][prefix + "-TOTAL_FORMS"] = kwargs["data"][
+                        prefix + "-INITIAL_FORMS"
+                    ]
         super(FormSet, self).__init__(*args, **kwargs)
 
     def check_duplicate(self, key_names, error_msg="", check_null=False):
@@ -500,9 +512,10 @@ class FormSet(CustomForm, BaseFormSet):
             form = self.forms[i]
             if not form.is_valid():
                 continue
-            item = [key_name in form.cleaned_data and
-                    form.cleaned_data[key_name]
-                    for key_name in key_names]
+            item = [
+                key_name in form.cleaned_data and form.cleaned_data[key_name]
+                for key_name in key_names
+            ]
             if not check_null and not [v for v in item if v]:
                 continue
             if item in items:
@@ -514,13 +527,13 @@ class FormSet(CustomForm, BaseFormSet):
         if self.readonly:
             for k in form.fields:
                 # django 1.9: use disabled
-                form.fields[k].widget.attrs['readonly'] = True
+                form.fields[k].widget.attrs["readonly"] = True
                 clean = get_readonly_clean(k)
-                clean.__name__ = 'clean_' + k
-                clean.__doc__ = 'autogenerated: clean_' + k
+                clean.__name__ = "clean_" + k
+                clean.__doc__ = "autogenerated: clean_" + k
                 setattr(form, clean.__name__, types.MethodType(clean, form))
         if self.can_delete:
-            form.fields[DELETION_FIELD_NAME].label = ''
+            form.fields[DELETION_FIELD_NAME].label = ""
             form.fields[DELETION_FIELD_NAME].widget = self.delete_widget()
 
     def _should_delete_form(self, form):
@@ -531,10 +544,12 @@ class FormSet(CustomForm, BaseFormSet):
         if form.cleaned_data.get(DELETION_FIELD_NAME, False):
             return True
         if not form.cleaned_data or not [
-                key for key in form.cleaned_data
-                if key != DELETION_FIELD_NAME and
-                   form.cleaned_data[key] is not None and
-                   form.cleaned_data[key] != '']:
+            key
+            for key in form.cleaned_data
+            if key != DELETION_FIELD_NAME
+            and form.cleaned_data[key] is not None
+            and form.cleaned_data[key] != ""
+        ]:
             form.cleaned_data[DELETION_FIELD_NAME] = True
             return True
         return False
@@ -552,10 +567,7 @@ class FieldType(object):
         self.extra_args = extra_args
 
     def get_choices(self, initial=None):
-        args = {
-            'empty_first': not self.is_multiple,
-            'initial': initial
-        }
+        args = {"empty_first": not self.is_multiple, "initial": initial}
         if self.extra_args:
             args.update(self.extra_args)
         return self.model.get_types(**args)
@@ -579,12 +591,14 @@ class FormHeader(object):
         if self.help_message:
             help_message = """
             <div class="alert alert-info" role="alert">{}</div>""".format(
-                self.help_message)
+                self.help_message
+            )
         if not self.collapse:
             return mark_safe(
                 "<h{level}>{label}</h{level}>{help_message}".format(
-                    label=self.label, level=self.level,
-                    help_message=help_message))
+                    label=self.label, level=self.level, help_message=help_message
+                )
+            )
         html = """<div id="collapse-parent-{slug}" class="collapse-form">
   <div class="card">
     <div class="card-header" id="collapse-head-{slug}">
@@ -604,30 +618,36 @@ class FormHeader(object):
         data-parent="#colapse-parent-{slug}">
       <div class="card-body">
       {help_message}
-""".format(label=self.label, slug=slugify(self.label), level=self.level,
-           help_message=help_message)
+""".format(
+            label=self.label,
+            slug=slugify(self.label),
+            level=self.level,
+            help_message=help_message,
+        )
         return mark_safe(html)
 
     def render_end(self):
         if not self.collapse:
             return ""
-        return mark_safe("""
+        return mark_safe(
+            """
       </div>
     </div>
   </div>
-  </div>""")
+  </div>"""
+        )
 
 
 class IshtarForm(forms.Form, BSForm):
     TYPES = []  # FieldType list
     CONDITIONAL_FIELDS = []  # dynamic conditions on field display
-                             # can be dynamic with "get_conditional_fields"
+    # can be dynamic with "get_conditional_fields"
     PROFILE_FILTER = {}  # profile key associated to field list
     HEADERS = {}  # field key associated to FormHeader instance
     # permission check for widget options, ex: forms_common.DocumentForm
     OPTIONS_PERMISSIONS = {}
     SITE_KEYS = {}  # archaeological sites fields and associated translation key
-                    # to manage translation
+    # to manage translation
 
     def __init__(self, *args, **kwargs):
         super(IshtarForm, self).__init__(*args, **kwargs)
@@ -641,7 +661,7 @@ class IshtarForm(forms.Form, BSForm):
                     for field_key in self.PROFILE_FILTER[profile_key]:
                         if field_key in self.fields.keys():
                             self.fields.pop(field_key)
-        if getattr(self, 'confirm', False):
+        if getattr(self, "confirm", False):
             return
         for field in self.TYPES:
             self._init_type(field)
@@ -655,8 +675,9 @@ class IshtarForm(forms.Form, BSForm):
         for field_name, permissions, options in self.OPTIONS_PERMISSIONS:
             if field_name not in self.fields or not getattr(self, "user", None):
                 continue
-            if not [True for permission in permissions
-                    if self.user.has_perm(permission)]:
+            if not [
+                True for permission in permissions if self.user.has_perm(permission)
+            ]:
                 continue
             for option, value in options.items():
                 setattr(self.fields[field_name].widget, option, value)
@@ -679,8 +700,7 @@ class IshtarForm(forms.Form, BSForm):
         return self.current_header
 
     def extra_render(self):
-        return (self.get_conditional() or "") + (
-                self.get_conditional_filters() or "")
+        return (self.get_conditional() or "") + (self.get_conditional_filters() or "")
 
     HIDE_JS_TEMPLATE = """
     var %(id)s_item_show_list = ['%(item_list)s'];
@@ -712,7 +732,7 @@ class IshtarForm(forms.Form, BSForm):
 
     def get_conditional(self):
         conditional_fields = self.CONDITIONAL_FIELDS
-        if hasattr(self, 'get_conditional_fields'):
+        if hasattr(self, "get_conditional_fields"):
             conditional_fields = self.get_conditional_fields()
         if not conditional_fields or not self.TYPES:
             return
@@ -725,17 +745,18 @@ class IshtarForm(forms.Form, BSForm):
                 continue
             model = type_dict[condition_field]
             condition_ids = [
-                str(item.pk) for item in model.objects.filter(
-                    **{condition_attr: condition_val}).all()
+                str(item.pk)
+                for item in model.objects.filter(
+                    **{condition_attr: condition_val}
+                ).all()
             ]
             name = self.prefix + "-" + condition_field
-            target_names = [
-                self.prefix + "-" + name for name in target_names
-            ]
+            target_names = [self.prefix + "-" + name for name in target_names]
             if not condition_ids:
-                html += self.HIDE_JS_TEMPLATE  % {
+                html += self.HIDE_JS_TEMPLATE % {
                     "item_list": "','".join(target_names),
-                    "id": name.replace("-", "_")}
+                    "id": name.replace("-", "_"),
+                }
                 continue
             html += self.CONDITIONAL_JS_TEMPLATE % {
                 "id": name.replace("-", "_"),
@@ -781,10 +802,13 @@ class IshtarForm(forms.Form, BSForm):
     """
 
     def get_conditional_filters(self):
-        if not hasattr(self, 'get_conditional_filter_fields'):
+        if not hasattr(self, "get_conditional_filter_fields"):
             return
-        conditional_fields, excluded_fields, all_values = \
-            self.get_conditional_filter_fields()
+        (
+            conditional_fields,
+            excluded_fields,
+            all_values,
+        ) = self.get_conditional_filter_fields()
 
         types = [typ.key for typ in self.TYPES]
         html = ""
@@ -802,8 +826,7 @@ class IshtarForm(forms.Form, BSForm):
                 if idx:
                     filter_list += ",\n"
                 filter_list += '  "%s": {\n' % input_pk
-                for idx2, output in enumerate(
-                        conditional_fields[input_key][input_pk]):
+                for idx2, output in enumerate(conditional_fields[input_key][input_pk]):
                     if idx2:
                         filter_list += ",\n"
                     if output[0] in excluded_fields:
@@ -816,7 +839,7 @@ class IshtarForm(forms.Form, BSForm):
                 "id": cidx,
                 "name": name,
                 "filter_list": filter_list,
-                "prefix": self.prefix or ""
+                "prefix": self.prefix or "",
             }
             html += "var %s_other_widget_list = [" % cidx
             for idx, k in enumerate(all_values):
@@ -848,7 +871,7 @@ class TableSelect(IshtarForm):
     def __init__(self, *args, **kwargs):
         super(TableSelect, self).__init__(*args, **kwargs)
         alt_names = {}
-        if hasattr(self, '_model'):
+        if hasattr(self, "_model"):
             if hasattr(self._model, "get_alt_names"):
                 alt_names = self._model.get_alt_names()
 
@@ -860,14 +883,13 @@ class TableSelect(IshtarForm):
 
         for k in self.fields:
             self.fields[k].required = False  # no field is required for search
-            cls = 'form-control'
-            if k == 'search_vector':
+            cls = "form-control"
+            if k == "search_vector":
                 cls += " search-vector"
-            self.fields[k].widget.attrs['class'] = cls
-            self.fields[k].alt_name = alt_names[k].search_key \
-                if k in alt_names else k
+            self.fields[k].widget.attrs["class"] = cls
+            self.fields[k].alt_name = alt_names[k].search_key if k in alt_names else k
         key = list(self.fields.keys())[0]
-        self.fields[key].widget.attrs['autofocus'] = 'autofocus'
+        self.fields[key].widget.attrs["autofocus"] = "autofocus"
 
     def get_input_ids(self):
         return list(self.fields.keys())
@@ -877,24 +899,30 @@ class HistorySelect(CustomForm, TableSelect):
     history_creator = forms.IntegerField(
         label=_("Created by"),
         widget=widgets.JQueryAutoComplete(
-            reverse_lazy('autocomplete-user'),
-            associated_model=User), required=False
+            reverse_lazy("autocomplete-user"), associated_model=User
+        ),
+        required=False,
     )
     history_modifier = forms.IntegerField(
         label=_("Last modified by"),
         widget=widgets.JQueryAutoComplete(
-            reverse_lazy('autocomplete-user'),
-            associated_model=User), required=False
+            reverse_lazy("autocomplete-user"), associated_model=User
+        ),
+        required=False,
     )
     modified_before = forms.DateField(
-        label=_("Modified before"), widget=DatePicker,
-        required=False)
+        label=_("Modified before"), widget=DatePicker, required=False
+    )
     modified_after = forms.DateField(
-        label=_("Modified after"), widget=DatePicker,
-        required=False)
+        label=_("Modified after"), widget=DatePicker, required=False
+    )
     _explicit_ordering = True
-    CURRENT_FIELDS = ["history_creator", "history_modifier",
-                      "modified_before", "modified_after"]
+    CURRENT_FIELDS = [
+        "history_creator",
+        "history_modifier",
+        "modified_before",
+        "modified_after",
+    ]
 
     def __init__(self, *args, **kwargs):
         super(HistorySelect, self).__init__(*args, **kwargs)
@@ -913,21 +941,25 @@ class HistorySelect(CustomForm, TableSelect):
 class DocumentItemSelect(HistorySelect):
     documents__image__isnull = forms.NullBooleanField(label=_("Has an image?"))
     documents__associated_file__isnull = forms.NullBooleanField(
-        label=_("Has an attached file?"))
+        label=_("Has an attached file?")
+    )
     documents__associated_url__isnull = forms.NullBooleanField(
-        label=_("Has a web address?"))
+        label=_("Has a web address?")
+    )
     CURRENT_FIELDS = [
-        'documents__image__isnull',
-        'documents__associated_file__isnull',
-        'documents__associated_url__isnull',
-        "history_creator", "history_modifier",
-        "modified_before", "modified_after"
+        "documents__image__isnull",
+        "documents__associated_file__isnull",
+        "documents__associated_url__isnull",
+        "history_creator",
+        "history_modifier",
+        "modified_before",
+        "modified_after",
     ]
     _explicit_ordering = True
 
 
 def get_now():
-    format = formats.get_format('DATE_INPUT_FORMATS')[0]
+    format = formats.get_format("DATE_INPUT_FORMATS")[0]
     return datetime.datetime.now().strftime(format)
 
 
@@ -936,10 +968,10 @@ class ClosingDateFormSelection(IshtarForm):
     end_date = DateField(label=_("Closing date"))
 
     def __init__(self, *args, **kwargs):
-        if 'initial' not in kwargs:
-            kwargs['initial'] = {}
-        if not kwargs['initial'].get('end_date', None):
-            kwargs['initial']['end_date'] = datetime.date.today()
+        if "initial" not in kwargs:
+            kwargs["initial"] = {}
+        if not kwargs["initial"].get("end_date", None):
+            kwargs["initial"]["end_date"] = datetime.date.today()
         super(ClosingDateFormSelection, self).__init__(*args, **kwargs)
 
 
@@ -948,12 +980,22 @@ def has_map():
 
 
 def get_form_selection(
-        class_name, label, key, model, base_form, get_url,
-        not_selected_error=_("You should select an item."), new=False,
-        new_message=_("Add a new item"), get_full_url=None,
-        gallery=False, map=False, multi=False, base_form_select=None,
-        alt_pk_field=None
-    ):
+    class_name,
+    label,
+    key,
+    model,
+    base_form,
+    get_url,
+    not_selected_error=_("You should select an item."),
+    new=False,
+    new_message=_("Add a new item"),
+    get_full_url=None,
+    gallery=False,
+    map=False,
+    multi=False,
+    base_form_select=None,
+    alt_pk_field=None,
+):
     """
     Generate a class selection form
         class_name -- name of the class
@@ -967,20 +1009,22 @@ def get_form_selection(
         gallery -- display a gallery
         map -- display a map
     """
-    attrs = {'_main_key': key,
-             '_not_selected_error': not_selected_error,
-             'form_label': label,
-             'associated_models': {key: model},
-             'currents': {key: model}}
+    attrs = {
+        "_main_key": key,
+        "_not_selected_error": not_selected_error,
+        "form_label": label,
+        "associated_models": {key: model},
+        "currents": {key: model},
+    }
     widget_kwargs = {"new": new, "new_message": new_message}
     if get_full_url:
-        widget_kwargs['source_full'] = reverse_lazy(get_full_url)
+        widget_kwargs["source_full"] = reverse_lazy(get_full_url)
     if gallery:
-        widget_kwargs['gallery'] = True
+        widget_kwargs["gallery"] = True
     if map:
-        widget_kwargs['map'] = models.profile_mapping()
+        widget_kwargs["map"] = models.profile_mapping()
     if multi:
-        widget_kwargs['multiple_select'] = True
+        widget_kwargs["multiple_select"] = True
         field = forms.CharField
         valid = models.valid_ids
     else:
@@ -990,12 +1034,15 @@ def get_form_selection(
     if alt_pk_field:
         key = alt_pk_field
     attrs[key] = field(
-        label="", required=False,
+        label="",
+        required=False,
         validators=[valid(model)],
-        widget=widgets.DataTable(reverse_lazy(get_url), base_form, model,
-                                 **widget_kwargs))
+        widget=widgets.DataTable(
+            reverse_lazy(get_url), base_form, model, **widget_kwargs
+        ),
+    )
 
-    attrs['SEARCH_AND_SELECT'] = True
+    attrs["SEARCH_AND_SELECT"] = True
     if not base_form_select:
         base_form_select = forms.Form
     if not isinstance(base_form_select, (tuple, list)):
@@ -1012,7 +1059,7 @@ def get_data_from_formset(data):
     for k in data:
         if not data[k]:
             continue
-        keys = k.split('-')
+        keys = k.split("-")
         if len(keys) < 3:
             continue
         try:
@@ -1032,30 +1079,30 @@ class ManageOldType(IshtarForm):
         init_data is used to manage deactivated items in list when editing
         old data
         """
-        prefix = kwargs.get('prefix') or ''
+        prefix = kwargs.get("prefix") or ""
         self.init_data = {}
-        if 'data' in kwargs and kwargs['data']:
-            for k in kwargs['data']:
+        if "data" in kwargs and kwargs["data"]:
+            for k in kwargs["data"]:
                 if prefix not in k:
                     continue
-                new_k = k[len(prefix) + 1:]
-                if hasattr(kwargs['data'], 'getlist'):
-                    items = kwargs['data'].getlist(k)
+                new_k = k[len(prefix) + 1 :]
+                if hasattr(kwargs["data"], "getlist"):
+                    items = kwargs["data"].getlist(k)
                 else:
-                    items = [kwargs['data'][k]]
+                    items = [kwargs["data"][k]]
                 for val in items:
                     if not val:
                         continue
                     if new_k not in self.init_data:
                         self.init_data[new_k] = []
                     self.init_data[new_k].append(val)
-        if 'initial' in kwargs and kwargs['initial']:
-            for k in kwargs['initial']:
+        if "initial" in kwargs and kwargs["initial"]:
+            for k in kwargs["initial"]:
                 if k not in self.init_data or not self.init_data[k]:
-                    if hasattr(kwargs['initial'], 'getlist'):
-                        items = kwargs['initial'].getlist(k)
+                    if hasattr(kwargs["initial"], "getlist"):
+                        items = kwargs["initial"].getlist(k)
                     else:
-                        items = [kwargs['initial'][k]]
+                        items = [kwargs["initial"][k]]
                     for val in items:
                         if not val:
                             continue
@@ -1071,7 +1118,8 @@ class ManageOldType(IshtarForm):
         if field.key not in self.fields:
             return
         self.fields[field.key].choices = field.get_choices(
-            initial=self.init_data.get(field.key))
+            initial=self.init_data.get(field.key)
+        )
         self.fields[field.key].help_text = field.get_help()
 
 
@@ -1088,33 +1136,31 @@ class QAForm(CustomForm, ManageOldType):
     )
 
     def __init__(self, *args, **kwargs):
-        self.items = kwargs.pop('items')
-        self.confirm = kwargs.pop('confirm')
+        self.items = kwargs.pop("items")
+        self.confirm = kwargs.pop("confirm")
         super(QAForm, self).__init__(*args, **kwargs)
         for k in list(self.fields.keys()):
             if self.MULTI and k in self.SINGLE_FIELDS:
                 self.fields.pop(k)
                 continue
             if self.confirm:
-                if 'data' not in kwargs or not kwargs['data'].get(k, None):
+                if "data" not in kwargs or not kwargs["data"].get(k, None):
                     self.fields.pop(k)
                     continue
-                if getattr(self.fields[k].widget, 'allow_multiple_selected',
-                           None):
+                if getattr(self.fields[k].widget, "allow_multiple_selected", None):
                     self.fields[k].widget = forms.MultipleHiddenInput()
                 else:
                     self.fields[k].widget = forms.HiddenInput()
-                if k in kwargs['data'] and kwargs['data'][k]:
+                if k in kwargs["data"] and kwargs["data"][k]:
                     if hasattr(self, "_get_" + k):
-                        value = getattr(
-                            self, "_get_" + k)(kwargs['data'][k])
+                        value = getattr(self, "_get_" + k)(kwargs["data"][k])
                         if value is None:
                             self.fields.pop(k)
                             continue
                         self.fields[k].rendered_value = value
                     elif hasattr(self.fields[k], "choices"):
                         values = []
-                        for v in kwargs['data'].getlist(k):
+                        for v in kwargs["data"].getlist(k):
                             dct_choices = {}
                             for key, value in self.fields[k].choices:
                                 if isinstance(value, (list, tuple)):
@@ -1125,22 +1171,21 @@ class QAForm(CustomForm, ManageOldType):
                                 values.append(str(dct_choices[v]))
                             elif int(v) in list(dct_choices.keys()):
                                 values.append(str(dct_choices[int(v)]))
-                        self.fields[k].rendered_value = mark_safe(
-                            " ; ".join(values))
+                        self.fields[k].rendered_value = mark_safe(" ; ".join(values))
             if k not in self.REPLACE_FIELDS:
-                self.fields[k].label = str(self.fields[k].label) + \
-                                       str(_(" - append to existing"))
+                self.fields[k].label = str(self.fields[k].label) + str(
+                    _(" - append to existing")
+                )
             else:
-                self.fields[k].label = str(self.fields[k].label) + \
-                                       str(_(" - replace"))
+                self.fields[k].label = str(self.fields[k].label) + str(_(" - replace"))
 
     def _set_value(self, item, base_key):
         value = self.cleaned_data[base_key]
         if not value:
             return
-        key = base_key[len(self.PREFIX):]
+        key = base_key[len(self.PREFIX) :]
         field = item._meta.get_field(key)
-        if getattr(field, 'related_model', None):
+        if getattr(field, "related_model", None):
             is_list = isinstance(value, (list, tuple))
             if not is_list:
                 value = [value]
@@ -1150,7 +1195,7 @@ class QAForm(CustomForm, ManageOldType):
                     v = field.related_model.objects.get(pk=v)
                 new_value.append(v)
             value = new_value if is_list else new_value[0]
-        if getattr(field, 'many_to_many', None):
+        if getattr(field, "many_to_many", None):
             if type(value) not in (list, tuple):
                 value = [value]
             for v in value:
@@ -1184,8 +1229,8 @@ class QAForm(CustomForm, ManageOldType):
     def save(self, items, user):
         for item in items:
             for base_key in self.cleaned_data:
-                if hasattr(self, '_set_' + base_key):
-                    getattr(self, '_set_' + base_key)(item, user)
+                if hasattr(self, "_set_" + base_key):
+                    getattr(self, "_set_" + base_key)(item, user)
                 else:
                     self._set_value(item, base_key)
             item.history_modifier = user
@@ -1197,16 +1242,17 @@ class DocumentGenerationForm(forms.Form):
     """
     Form to generate document by choosing the template
     """
+
     _associated_model = None  # ex: AdministrativeAct
     # ex: 'archaeological_operations.models.AdministrativeAct'
-    _associated_object_name = ''
+    _associated_object_name = ""
     document_template = forms.ChoiceField(label=_("Template"), choices=[])
 
     def __init__(self, *args, **kwargs):
         super(DocumentGenerationForm, self).__init__(*args, **kwargs)
-        self.fields['document_template'].choices = \
-            models.DocumentTemplate.get_tuples(
-                dct={'associated_model__klass': self._associated_object_name})
+        self.fields["document_template"].choices = models.DocumentTemplate.get_tuples(
+            dct={"associated_model__klass": self._associated_object_name}
+        )
 
     def save(self, object_pk):
         try:
@@ -1215,7 +1261,8 @@ class DocumentGenerationForm(forms.Form):
             return
         try:
             template = models.DocumentTemplate.objects.get(
-                pk=self.cleaned_data.get('document_template'))
+                pk=self.cleaned_data.get("document_template")
+            )
         except models.DocumentTemplate.DoesNotExist:
             return
         return template.publish(c_object)