Flake8

1 files changed, 300 insertions, 221 deletions

diff --git a/archaeological_operations/forms.py b/archaeological_operations/forms.py
index 27f8bae08..9a8380367 100644
--- a/archaeological_operations/forms.py
+++ b/archaeological_operations/forms.py
@@ -99,16 +99,16 @@ class ParcelForm(forms.Form):
         """Check required fields"""
         if any(self.errors):
             return
-        if not self.cleaned_data or (DELETION_FIELD_NAME in self.cleaned_data \
+        if not self.cleaned_data or (DELETION_FIELD_NAME in self.cleaned_data
            and self.cleaned_data[DELETION_FIELD_NAME]):
             return
         if not self.cleaned_data.get('parcel_number') and \
            self.cleaned_data.get('section') != 'DP':
             return {}
         for key in ('town', 'section'):
-            if not key in self.cleaned_data or not self.cleaned_data[key]:
-                raise forms.ValidationError(_(u"Town section and parcel number "
-                                              u"fields are required."))
+            if key not in self.cleaned_data or not self.cleaned_data[key]:
+                raise forms.ValidationError(_(u"Town section and parcel number"
+                                              u" fields are required."))
         return self.cleaned_data
 
     @classmethod
@@ -157,7 +157,7 @@ class ParcelForm(forms.Form):
 
     @classmethod
     def _format_parcels(cls, parcels):
-        sortkeyfn = lambda s:(s[0], s[1], s[2])
+        sortkeyfn = lambda s: (s[0], s[1], s[2])
         parcels = sorted(parcels, key=sortkeyfn)
         grouped = []
         for keys, parcel_grp in groupby(parcels, key=sortkeyfn):
@@ -165,12 +165,12 @@ class ParcelForm(forms.Form):
             keys.append([gp[-1] for gp in parcel_grp])
             grouped.append(keys)
         res = ''
-        c_town, c_section, c_year = '', '', ''
+        c_town, c_section = '', ''
         for idx, parcel in enumerate(grouped):
             town, year, section, parcel_numbers = parcel
             if c_town != town:
                 c_town = town
-                c_section, c_year = '', ''
+                c_section = ''
                 if idx:
                     res += " ; "
                 res += town + u' : '
@@ -183,14 +183,17 @@ class ParcelForm(forms.Form):
                 res += " (%s)" % unicode(year)
         return res
 
+
 class ParcelSelectionForm(forms.Form):
     _town = forms.ChoiceField(label=_("Town"), choices=(), required=False,
-                             validators=[valid_id(models.Town)])
-    _parcel_selection = forms.CharField(label=_(u"Full text input"),
-                     widget=SelectParcelWidget(attrs={'class':'parcel-select'}),
-                     max_length=100, help_text=_(u"example: \"2013: XD:1 to "\
-                     u"13,24,33 to 39, YD:24\" or \"AB:24,AC:42\""),
-                     required=False)
+                              validators=[valid_id(models.Town)])
+    _parcel_selection = forms.CharField(
+        label=_(u"Full text input"),
+        widget=SelectParcelWidget(attrs={'class': 'parcel-select'}),
+        help_text=_(u"example: \"2013: XD:1 to 13,24,33 to 39, YD:24\" or "
+                    u"\"AB:24,AC:42\""),
+        max_length=100, required=False)
+
 
 class ParcelFormSet(FormSet):
     SELECTION_FORM = ParcelSelectionForm
@@ -213,8 +216,9 @@ class ParcelFormSet(FormSet):
 
     def rearrange_parcels(self, parcels):
         """
-        Simple database ordering is not possible as a numeric ordering of parcel
-        number have to be made but with parcel number not strictly numeric
+        Simple database ordering is not possible as a numeric ordering of
+        parcel number have to be made but with parcel number not strictly
+        numeric
         Very complicated for a simple thing :(
         """
         prefix, ordering_keys, values = '', {}, {}
@@ -250,7 +254,7 @@ class ParcelFormSet(FormSet):
             reverse_ordering_keys[tuple(ordering_keys[number])] = number
 
         for new_idx, keys in enumerate(sorted(reverse_ordering_keys.keys(),
-                                         key=self._parcel_sorting)):
+                                       key=self._parcel_sorting)):
             number = reverse_ordering_keys[keys]
             prefx = '%s-%d-' % (prefix, new_idx)
             for field in values[number]:
@@ -310,14 +314,15 @@ class ParcelFormSet(FormSet):
             for idx, parcel in enumerate(parcels):
                 form = self._construct_form(idx + c_max)
                 for k in parcel:
-                    self.data[form.prefix+'-'+k] = parcel[k]
+                    self.data[form.prefix + '-' + k] = parcel[k]
                 # reconstruct with correct binded data
                 form = self._construct_form(idx + c_max)
                 form.cleaned_data = parcel
                 self.forms.append(form)
                 self._errors.append(None)
             self.forms.append(extra_form)
-            self.data[self.prefix+'-'+TOTAL_FORM_COUNT] = c_max + len(parcels)
+            self.data[self.prefix + '-' + TOTAL_FORM_COUNT] = c_max + \
+                len(parcels)
             self.management_form.data = self.data
             self.management_form.is_valid()
         # Checks that no parcels are duplicated.
@@ -332,10 +337,11 @@ ParcelFormSet.form_label = _(u"Parcels")
 
 SRA_AGENT, created = PersonType.objects.get_or_create(txt_idx='sra_agent')
 HEAD_SCIENTIST, created = PersonType.objects.get_or_create(
-                                    txt_idx='head_scientist')
+    txt_idx='head_scientist')
 
 OPERATOR, created = OrganizationType.objects.get_or_create(txt_idx='operator')
 
+
 class OperationSelect(TableSelect):
     year = forms.IntegerField(label=_("Year"))
     operation_code = forms.IntegerField(label=_(u"Numeric reference"))
@@ -347,19 +353,26 @@ class OperationSelect(TableSelect):
     operation_type = forms.ChoiceField(label=_(u"Operation type"),
                                        choices=[])
     scientist = forms.IntegerField(
-        widget=widgets.JQueryAutoComplete(reverse_lazy('autocomplete-person',
-          args=["_".join(
-         [unicode(HEAD_SCIENTIST.pk), unicode(SRA_AGENT.pk)])]),
-        associated_model=Person), label=_(u"Scientist in charge"))
+        widget=widgets.JQueryAutoComplete(
+            reverse_lazy('autocomplete-person',
+                         args=["_".join([unicode(HEAD_SCIENTIST.pk),
+                                         unicode(SRA_AGENT.pk)])]),
+            associated_model=Person),
+        label=_(u"Scientist in charge"))
     in_charge = forms.IntegerField(
-        widget=widgets.JQueryAutoComplete(reverse_lazy('autocomplete-person',
-          args=["_".join(
-         [unicode(PersonType.objects.get(txt_idx='sra_agent').pk)])]),
-        associated_model=Person), label=_(u"In charge"))
-    operator = forms.IntegerField(label=_("Operator"),
-        widget=widgets.JQueryAutoComplete(reverse_lazy(
-                'autocomplete-organization', args=[OPERATOR.pk]),
-        associated_model=Organization),
+        widget=widgets.JQueryAutoComplete(
+            reverse_lazy(
+                'autocomplete-person',
+                args=["_".join(
+                    [unicode(PersonType.objects.get(txt_idx='sra_agent').pk)])]
+            ),
+            associated_model=Person),
+        label=_(u"In charge"))
+    operator = forms.IntegerField(
+        label=_("Operator"),
+        widget=widgets.JQueryAutoComplete(
+            reverse_lazy('autocomplete-organization', args=[OPERATOR.pk]),
+            associated_model=Organization),
         validators=[valid_id(Organization)])
     remains = forms.ChoiceField(label=_(u"Remains"), choices=[])
     periods = forms.ChoiceField(label=_(u"Periods"), choices=[])
@@ -374,17 +387,18 @@ class OperationSelect(TableSelect):
     parcel = ParcelField(label=_("Parcel (section/number)"))
     end_date = forms.NullBooleanField(label=_(u"Is open?"))
     history_creator = forms.IntegerField(
-            label=_(u"Created by"),
-            widget=widgets.JQueryAutoComplete(
-                reverse_lazy('autocomplete-person',
-                args=['0', 'user']),
-                associated_model=Person),
-            validators=[valid_id(Person)])
+        label=_(u"Created by"),
+        widget=widgets.JQueryAutoComplete(
+            reverse_lazy('autocomplete-person', args=['0', 'user']),
+            associated_model=Person),
+        validators=[valid_id(Person)])
 
     def __init__(self, *args, **kwargs):
         super(OperationSelect, self).__init__(*args, **kwargs)
-        self.fields['operation_type'].choices = models.OperationType.get_types()
-        self.fields['operation_type'].help_text = models.OperationType.get_help()
+        self.fields['operation_type'].choices = \
+            models.OperationType.get_types()
+        self.fields['operation_type'].help_text = \
+            models.OperationType.get_help()
         self.fields['remains'].choices = models.RemainType.get_types()
         self.fields['remains'].help_text = models.RemainType.get_help()
         self.fields['periods'].choices = models.Period.get_types()
@@ -397,15 +411,17 @@ class OperationSelect(TableSelect):
         ids.append('parcel_1')
         return ids
 
+
 class OperationFormSelection(forms.Form):
     form_label = _(u"Operation search")
-    associated_models = {'pk':models.Operation}
-    currents = {'pk':models.Operation}
-    pk = forms.IntegerField(label="", required=False,
-       widget=widgets.JQueryJqGrid(reverse_lazy('get-operation'),
-             OperationSelect, models.Operation,
-             source_full=reverse_lazy('get-operation-full')),
-       validators=[valid_id(models.Operation)])
+    associated_models = {'pk': models.Operation}
+    currents = {'pk': models.Operation}
+    pk = forms.IntegerField(
+        label="", required=False,
+        widget=widgets.JQueryJqGrid(
+            reverse_lazy('get-operation'), OperationSelect, models.Operation,
+            source_full=reverse_lazy('get-operation-full')),
+        validators=[valid_id(models.Operation)])
 
     def clean(self):
         cleaned_data = self.cleaned_data
@@ -413,6 +429,7 @@ class OperationFormSelection(forms.Form):
             raise forms.ValidationError(_(u"You should select an operation."))
         return cleaned_data
 
+
 class OperationCodeInput(forms.TextInput):
     """Manage auto complete when changing year in form"""
     def render(self, *args, **kwargs):
@@ -433,38 +450,42 @@ class OperationCodeInput(forms.TextInput):
             }
         }
         $(document).ready(initialyse_operation_code());
-        //--></script>\n""" % {'base_name':base_name, 'name':name,
-                               'url':reverse_lazy('get_available_operation_code')}
+        //--></script>\n""" % {
+            'base_name': base_name, 'name': name,
+            'url': reverse_lazy('get_available_operation_code')}
         return mark_safe(rendered + js)
 
 if FILES_AVAILABLE:
     class OperationFormFileChoice(forms.Form):
         form_label = _(u"Associated file")
-        associated_models = {'associated_file':File,}
-        currents = {'associated_file':File}
-        associated_file = forms.IntegerField(label=_(u"Archaelogical file"),
-             widget=widgets.JQueryAutoComplete(reverse_lazy('autocomplete-file'),
-                                               associated_model=File),
-             validators=[valid_id(File)], required=False)
+        associated_models = {'associated_file': File, }
+        currents = {'associated_file': File}
+        associated_file = forms.IntegerField(
+            label=_(u"Archaelogical file"),
+            widget=widgets.JQueryAutoComplete(
+                reverse_lazy('autocomplete-file'), associated_model=File),
+            validators=[valid_id(File)], required=False)
 
-SLICING = (("month",_(u"months")), ('year',_(u"years")),)
+SLICING = (("month", _(u"months")), ('year', _(u"years")),)
 
-DATE_SOURCE = (('creation',_(u"Creation date")),
-               ("start",_(u"Start of field work")))
+DATE_SOURCE = (('creation', _(u"Creation date")),
+               ("start", _(u"Start of field work")))
 
 PREVENTIVE_RESARCH = (('all', _('All')),
                       ('preventive', _(u"Preventive")),
                       ('research', _(u"Research")),)
 
+
 class DashboardForm(forms.Form):
     slicing = forms.ChoiceField(label=_("Slicing"), choices=SLICING,
-                              required=False)
-    department_detail = forms.BooleanField(label=_("Department detail"),
-                              required=False)
-    date_source = forms.ChoiceField(label=_("Date get from"),
-                            choices=DATE_SOURCE, required=False)
-    preventive_research = forms.ChoiceField(label=_("Preventive/Research"),
-                                    choices=PREVENTIVE_RESARCH, required=False)
+                                required=False)
+    department_detail = forms.BooleanField(
+        label=_("Department detail"), required=False)
+    date_source = forms.ChoiceField(
+        label=_("Date get from"), choices=DATE_SOURCE, required=False)
+    preventive_research = forms.ChoiceField(
+        label=_("Preventive/Research"), choices=PREVENTIVE_RESARCH,
+        required=False)
     operation_type = forms.ChoiceField(label=_("Operation type"), choices=[],
                                        required=False)
     operator = forms.ChoiceField(label=_("Operator"), choices=[],
@@ -472,7 +493,7 @@ class DashboardForm(forms.Form):
     after = forms.DateField(label=_(u"Date after"),
                             widget=widgets.JQueryDate, required=False)
     before = forms.DateField(label=_(u"Date before"),
-                            widget=widgets.JQueryDate, required=False)
+                             widget=widgets.JQueryDate, required=False)
     with_report = forms.BooleanField(label=_("With reports"), required=False)
     with_finds = forms.BooleanField(label=_("With finds"), required=False)
 
@@ -480,15 +501,17 @@ class DashboardForm(forms.Form):
         if 'prefix' not in kwargs:
             kwargs['prefix'] = 'operations'
         super(DashboardForm, self).__init__(*args, **kwargs)
-        self.fields['operation_type'].choices = models.OperationType.get_types()
+        self.fields['operation_type'].choices = \
+            models.OperationType.get_types()
         self.fields['operator'].choices = [('', '--')]
-        self.fields['operator'].choices += [(orga.pk, orga.name)
-            for orga in Organization.objects.filter(operator__isnull=False)\
+        self.fields['operator'].choices += [
+            (orga.pk, orga.name)
+            for orga in Organization.objects.filter(operator__isnull=False)
                                             .order_by('name').distinct().all()]
 
     def get_show_detail(self):
         return hasattr(self, 'cleaned_data') and \
-           self.cleaned_data.get('department_detail')
+            self.cleaned_data.get('department_detail')
 
     def get_date_source(self):
         date_source = 'creation'
@@ -513,15 +536,16 @@ class DashboardForm(forms.Form):
         if self.cleaned_data.get('operator'):
             fltr['operator_id'] = self.cleaned_data['operator']
         if self.cleaned_data.get('after'):
-            fltr[date_source+'_date__gte'] = self.cleaned_data['after']
+            fltr[date_source + '_date__gte'] = self.cleaned_data['after']
         if self.cleaned_data.get('before'):
-            fltr[date_source+'_date__lte'] = self.cleaned_data['before']
+            fltr[date_source + '_date__lte'] = self.cleaned_data['before']
         if self.cleaned_data.get('with_report'):
             fltr['report_delivery_date__isnull'] = False
         if self.cleaned_data.get('with_finds'):
             fltr['context_record__base_finds__isnull'] = False
         return fltr
 
+
 class OperationFormGeneral(forms.Form):
     form_label = _(u"General")
     base_model = 'archaeological_site'
@@ -532,78 +556,92 @@ class OperationFormGeneral(forms.Form):
                          'operation_type': models.OperationType,
                          'archaeological_site': models.ArchaeologicalSite}
     pk = forms.IntegerField(required=False, widget=forms.HiddenInput)
-    scientist = forms.IntegerField(label=_("Head scientist"),
-        widget=widgets.JQueryAutoComplete(reverse_lazy('autocomplete-person',
-          args=["_".join(
-         [unicode(HEAD_SCIENTIST.pk), unicode(SRA_AGENT.pk)])]),
-        associated_model=Person,
-        limit={'person_types':(HEAD_SCIENTIST.pk, SRA_AGENT.pk)},
-        new=True),
+    scientist = forms.IntegerField(
+        label=_("Head scientist"),
+        widget=widgets.JQueryAutoComplete(
+            reverse_lazy('autocomplete-person',
+                         args=["_".join([unicode(HEAD_SCIENTIST.pk),
+                                         unicode(SRA_AGENT.pk)])]),
+            associated_model=Person,
+            limit={'person_types': (HEAD_SCIENTIST.pk, SRA_AGENT.pk)},
+            new=True),
         validators=[valid_id(Person)], required=False)
-    operator = forms.IntegerField(label=_("Operator"),
-        widget=widgets.JQueryAutoComplete(reverse_lazy(
-                'autocomplete-organization', args=[OPERATOR.pk]),
-        limit={'organization_type':(OPERATOR.pk,)},
-        associated_model=Organization, new=True),
+    operator = forms.IntegerField(
+        label=_("Operator"),
+        widget=widgets.JQueryAutoComplete(
+            reverse_lazy('autocomplete-organization', args=[OPERATOR.pk]),
+            limit={'organization_type': (OPERATOR.pk,)},
+            associated_model=Organization, new=True),
         validators=[valid_id(Organization)], required=False)
-    in_charge = forms.IntegerField(label=_("In charge"),
-        widget=widgets.JQueryAutoComplete(reverse_lazy('autocomplete-person',
-          args=["_".join([unicode(SRA_AGENT.pk)])]),
-        associated_model=Person,
-        limit={'person_types':[SRA_AGENT.pk]},
-        new=True),
+    in_charge = forms.IntegerField(
+        label=_("In charge"),
+        widget=widgets.JQueryAutoComplete(
+            reverse_lazy('autocomplete-person',
+                         args=["_".join([unicode(SRA_AGENT.pk)])]),
+            associated_model=Person,
+            limit={'person_types': [SRA_AGENT.pk]}, new=True),
         validators=[valid_id(Person)], required=False)
     operation_type = forms.ChoiceField(label=_(u"Operation type"),
                                        choices=[])
-    start_date = forms.DateField(label=_(u"Start date"), required=False,
-                                 widget=widgets.JQueryDate)
-    excavation_end_date = forms.DateField(label=_(u"Excavation end date"),
-                                 required=False, widget=widgets.JQueryDate)
-    report_delivery_date = forms.DateField(label=_(u"Report delivery date"),
-                                 required=False, widget=widgets.JQueryDate)
-    surface = forms.IntegerField(required=False, widget=widgets.AreaWidget,
-                           label=_(u"Total surface (m²)"),
-                           validators=[validators.MinValueValidator(0),
-                                       validators.MaxValueValidator(999999999)])
+    start_date = forms.DateField(
+        label=_(u"Start date"), required=False, widget=widgets.JQueryDate)
+    excavation_end_date = forms.DateField(
+        label=_(u"Excavation end date"), required=False,
+        widget=widgets.JQueryDate)
+    report_delivery_date = forms.DateField(
+        label=_(u"Report delivery date"), required=False,
+        widget=widgets.JQueryDate)
+    surface = forms.IntegerField(
+        required=False, widget=widgets.AreaWidget,
+        label=_(u"Total surface (m²)"),
+        validators=[validators.MinValueValidator(0),
+                    validators.MaxValueValidator(999999999)])
     year = forms.IntegerField(label=_(u"Year"),
-                              initial=lambda:datetime.datetime.now().year,
+                              initial=lambda: datetime.datetime.now().year,
                               validators=[validators.MinValueValidator(1900),
                                           validators.MaxValueValidator(2100)])
-    operation_code = forms.IntegerField(label=_(u"Operation code"),
-                    initial=models.Operation.get_available_operation_code,
-                    widget=OperationCodeInput(attrs={'readonly':'readonly'}))
+    operation_code = forms.IntegerField(
+        label=_(u"Operation code"),
+        initial=models.Operation.get_available_operation_code,
+        widget=OperationCodeInput(attrs={'readonly': 'readonly'}))
     common_name = forms.CharField(label=_(u"Generic name"), required=False,
                                   max_length=120, widget=forms.Textarea)
     operator_reference = forms.CharField(label=_(u"Operator reference"),
                                          required=False, max_length=20)
     archaeological_site = widgets.MultipleAutocompleteField(
-                                model=models.ArchaeologicalSite,
-                                label=_("Associated archaeological sites"),
-                                new=True, required=False)
+        model=models.ArchaeologicalSite,
+        label=_("Associated archaeological sites"), new=True, required=False)
     if settings.COUNTRY == 'fr':
-        negative_result = forms.NullBooleanField(required=False,
-                                      label=u"Résultat considéré comme négatif")
+        negative_result = forms.NullBooleanField(
+            required=False, label=u"Résultat considéré comme négatif")
         code_patriarche = forms.IntegerField(label=u"Code PATRIARCHE",
-                                required=False)
-        code_dracar = forms.CharField(label=u"Code DRACAR", required=False,
-                           validators=[validators.MaxLengthValidator(10)])
-        eas_number = forms.CharField(label=u"Numéro de l'EA", required=False,
-                           validators=[validators.MaxLengthValidator(20)])
+                                             required=False)
+        code_dracar = forms.CharField(
+            label=u"Code DRACAR", required=False,
+            validators=[validators.MaxLengthValidator(10)])
+        eas_number = forms.CharField(
+            label=u"Numéro de l'EA", required=False,
+            validators=[validators.MaxLengthValidator(20)])
         cira_date = forms.DateField(label=u"Date avis CIRA", required=False,
                                     widget=widgets.JQueryDate)
-        cira_rapporteur = forms.IntegerField(label=u"Rapporteur CIRA",
-        widget=widgets.JQueryAutoComplete(reverse_lazy('autocomplete-person',
-          args=["_".join([unicode(HEAD_SCIENTIST.pk), unicode(SRA_AGENT.pk)])]),
-        limit={'person_types':[SRA_AGENT.pk, HEAD_SCIENTIST.pk]},
-        associated_model=Person, new=True),
-        validators=[valid_id(Person)], required=False)
+        cira_rapporteur = forms.IntegerField(
+            label=u"Rapporteur CIRA",
+            widget=widgets.JQueryAutoComplete(
+                reverse_lazy('autocomplete-person',
+                             args=["_".join([unicode(HEAD_SCIENTIST.pk),
+                                             unicode(SRA_AGENT.pk)])]),
+                limit={'person_types': [SRA_AGENT.pk, HEAD_SCIENTIST.pk]},
+                associated_model=Person, new=True),
+            validators=[valid_id(Person)], required=False)
     comment = forms.CharField(label=_(u"Comment"), widget=forms.Textarea,
                               required=False)
 
     def __init__(self, *args, **kwargs):
         super(OperationFormGeneral, self).__init__(*args, **kwargs)
-        self.fields['operation_type'].choices = models.OperationType.get_types()
-        self.fields['operation_type'].help_text = models.OperationType.get_help()
+        self.fields['operation_type'].choices = \
+            models.OperationType.get_types()
+        self.fields['operation_type'].help_text = \
+            models.OperationType.get_help()
         # data POSTED
         if kwargs and kwargs['data'] \
            and 'readonly' in self.fields['operation_code'].widget.attrs:
@@ -614,11 +652,14 @@ class OperationFormGeneral(forms.Form):
         # verify the logic between start date and excavation end date
         if cleaned_data['excavation_end_date']:
             if not self.cleaned_data['start_date']:
-                raise forms.ValidationError(_(u"If you want to set an "
-                      u"excavation end date you have to provide a start date."))
-            if cleaned_data['excavation_end_date'] < cleaned_data['start_date']:
-                raise forms.ValidationError(_(u"The excavation end date "\
-                      u"cannot be before the start date."))
+                raise forms.ValidationError(
+                    _(u"If you want to set an excavation end date you have to "
+                      u"provide a start date."))
+            if cleaned_data['excavation_end_date'] \
+                    < cleaned_data['start_date']:
+                raise forms.ValidationError(
+                    _(u"The excavation end date cannot be before the start "
+                      u"date."))
         year = self.cleaned_data.get("year")
         operation_code = cleaned_data.get("operation_code")
         ops = models.Operation.objects.filter(year=year,
@@ -628,25 +669,29 @@ class OperationFormGeneral(forms.Form):
             ops = ops.exclude(pk=cleaned_data['pk'])
         if ops.count():
             max_val = models.Operation.objects.filter(year=year).aggregate(
-                                Max('operation_code'))["operation_code__max"]
+                Max('operation_code'))["operation_code__max"]
             msg = ''
             if year and max_val:
-                msg = _(u"Operation code already exist for "
-                   u"year: %(year)d - use a value bigger than %(last_val)d") % {
-                                               'year':year, 'last_val':max_val}
+                msg = _(
+                    u"Operation code already exist for year: %(year)d - use a "
+                    u"value bigger than %(last_val)d") % {
+                    'year': year, 'last_val': max_val}
             else:
-                msg =  _(u"Bad operation code")
+                msg = _(u"Bad operation code")
             raise forms.ValidationError(msg)
         return self.cleaned_data
 
+
 class OperationFormModifGeneral(OperationFormGeneral):
     operation_code = forms.IntegerField(label=_(u"Operation code"))
     if FILES_AVAILABLE:
-        currents = {'associated_file':File}
-        associated_file = forms.IntegerField(label=_(u"Archaelogical file"),
-         widget=widgets.JQueryAutoComplete(reverse_lazy('autocomplete-file'),
-                                           associated_model=File),
-         validators=[valid_id(File)], required=False)
+        currents = {'associated_file': File}
+        associated_file = forms.IntegerField(
+            label=_(u"Archaelogical file"),
+            widget=widgets.JQueryAutoComplete(
+                reverse_lazy('autocomplete-file'),
+                associated_model=File),
+            validators=[valid_id(File)], required=False)
 
     def __init__(self, *args, **kwargs):
         super(OperationFormModifGeneral, self).__init__(*args, **kwargs)
@@ -656,7 +701,8 @@ class OperationFormModifGeneral(OperationFormGeneral):
                                     'associated_file')
 
 OperationFormModifGeneral.associated_models = \
-                                OperationFormGeneral.associated_models.copy()
+    OperationFormGeneral.associated_models.copy()
+
 if FILES_AVAILABLE:
     OperationFormModifGeneral.associated_models['associated_file'] = File
 
@@ -671,26 +717,30 @@ class OperationFormPreventive(forms.Form):
     effective_man_days = forms.IntegerField(label=_(u"Effective man-days"),
                                             required=False)
     if settings.COUNTRY == 'fr':
-        fnap_financing = forms.FloatField(required=False,
-                               label=u"Pourcentage de financement FNAP",
-                               validators=[validators.MinValueValidator(0),
-                                           validators.MaxValueValidator(100)])
+        fnap_financing = forms.FloatField(
+            required=False, label=u"Pourcentage de financement FNAP",
+            validators=[validators.MinValueValidator(0),
+                        validators.MaxValueValidator(100)])
+
 
 class OperationFormPreventiveDiag(forms.Form):
     form_label = _("Preventive informations - diagnostic")
     if settings.COUNTRY == 'fr':
-        zoning_prescription = forms.NullBooleanField(required=False,
-                                            label=_(u"Prescription on zoning"))
-        large_area_prescription = forms.NullBooleanField(required=False,
-                                        label=_(u"Prescription on large area"))
+        zoning_prescription = forms.NullBooleanField(
+            required=False, label=_(u"Prescription on zoning"))
+        large_area_prescription = forms.NullBooleanField(
+            required=False, label=_(u"Prescription on large area"))
         geoarchaeological_context_prescription = forms.NullBooleanField(
-         required=False, label=_(u"Prescription on geoarchaeological context"))
+            required=False,
+            label=_(u"Prescription on geoarchaeological context"))
+
 
 class SelectedTownForm(forms.Form):
     form_label = _("Towns")
-    associated_models = {'town':Town}
+    associated_models = {'town': Town}
     town = forms.ChoiceField(label=_("Town"), choices=(),
                              validators=[valid_id(Town)])
+
     def __init__(self, *args, **kwargs):
         towns = None
         if 'data' in kwargs and 'TOWNS' in kwargs['data']:
@@ -707,14 +757,16 @@ class SelectedTownForm(forms.Form):
             self.fields['town'].choices = [('', '--')] + towns
 
 SelectedTownFormset = formset_factory(SelectedTownForm, can_delete=True,
-                                formset=TownFormSet)
+                                      formset=TownFormSet)
 SelectedTownFormset.form_label = _(u"Towns")
 
+
 class SelectedParcelForm(forms.Form):
     form_label = _("Parcels")
-    associated_models = {'parcel':models.Parcel}
-    parcel = forms.ChoiceField(label=_("Parcel"), choices=(),
-                             validators=[valid_id(models.Parcel)])
+    associated_models = {'parcel': models.Parcel}
+    parcel = forms.ChoiceField(
+        label=_("Parcel"), choices=(), validators=[valid_id(models.Parcel)])
+
     def __init__(self, *args, **kwargs):
         parcels = None
         if 'data' in kwargs and 'PARCELS' in kwargs['data']:
@@ -731,17 +783,18 @@ class SelectedParcelForm(forms.Form):
             self.fields['parcel'].choices = [('', '--')] + parcels
 
 SelectedParcelFormSet = formset_factory(SelectedParcelForm, can_delete=True,
-                                formset=ParcelFormSet)
+                                        formset=ParcelFormSet)
 SelectedParcelFormSet.form_label = _("Parcels")
 
 SelectedParcelGeneralFormSet = formset_factory(ParcelForm, can_delete=True,
-                                             formset=ParcelFormSet)
+                                               formset=ParcelFormSet)
 SelectedParcelGeneralFormSet.form_label = _("Parcels")
 
+
 class RemainForm(forms.Form):
     form_label = _("Remain types")
     base_model = 'remain'
-    associated_models = {'remain':models.RemainType}
+    associated_models = {'remain': models.RemainType}
     remain = forms.ChoiceField(label=_("Remain type"), required=False,
                                choices=[])
 
@@ -750,6 +803,7 @@ class RemainForm(forms.Form):
         self.fields['remain'].choices = models.RemainType.get_types()
         self.fields['remain'].help_text = models.RemainType.get_help()
 
+
 class RemainFormSet(FormSet):
     def clean(self):
         """Checks that no remain types are duplicated."""
@@ -760,10 +814,11 @@ RemainFormset = formset_factory(RemainForm, can_delete=True,
                                 formset=RemainFormSet)
 RemainFormset.form_label = _("Remain types")
 
+
 class PeriodForm(forms.Form):
     form_label = _("Periods")
     base_model = 'period'
-    associated_models = {'period':models.Period}
+    associated_models = {'period': models.Period}
     period = forms.ChoiceField(label=_("Period"), required=False,
                                choices=[])
 
@@ -772,6 +827,7 @@ class PeriodForm(forms.Form):
         self.fields['period'].choices = models.Period.get_types()
         self.fields['period'].help_text = models.Period.get_help()
 
+
 class PeriodFormSet(FormSet):
     def clean(self):
         """Checks that no period are duplicated."""
@@ -782,30 +838,33 @@ PeriodFormset = formset_factory(PeriodForm, can_delete=True,
                                 formset=PeriodFormSet)
 PeriodFormset.form_label = _("Periods")
 
+
 class ArchaeologicalSiteForm(forms.Form):
     reference = forms.CharField(label=_(u"Reference"), max_length=20)
     name = forms.CharField(label=_(u"Name"), max_length=200, required=False)
-    periods = forms.MultipleChoiceField(label=_("Periods"),
-                     choices=[], widget=widgets.Select2Multiple, required=False)
-    remains = forms.MultipleChoiceField(label=_("Remains"),
-                     choices=[], widget=widgets.Select2Multiple, required=False)
+    periods = forms.MultipleChoiceField(
+        label=_("Periods"), choices=[], widget=widgets.Select2Multiple,
+        required=False)
+    remains = forms.MultipleChoiceField(
+        label=_("Remains"), choices=[], widget=widgets.Select2Multiple,
+        required=False)
 
     def __init__(self, *args, **kwargs):
         self.limits = {}
         if 'limits' in kwargs:
-            limits = kwargs.pop('limits')
+            kwargs.pop('limits')
         super(ArchaeologicalSiteForm, self).__init__(*args, **kwargs)
         self.fields['periods'].choices = \
-                            models.Period.get_types(empty_first=False)
+            models.Period.get_types(empty_first=False)
         self.fields['periods'].help_text = models.Period.get_help()
         self.fields['remains'].choices = \
-                            models.RemainType.get_types(empty_first=False)
+            models.RemainType.get_types(empty_first=False)
         self.fields['remains'].help_text = models.RemainType.get_help()
 
     def clean_reference(self):
         reference = self.cleaned_data['reference']
-        if models.ArchaeologicalSite.objects.filter(
-                                reference=reference).count():
+        if models.ArchaeologicalSite.objects\
+                                    .filter(reference=reference).count():
             raise forms.ValidationError(_(u"This reference already exists."))
         return reference
 
@@ -821,19 +880,22 @@ class ArchaeologicalSiteForm(forms.Form):
             item.remains.add(remain)
         return item
 
+
 class ArchaeologicalSiteSelectionForm(forms.Form):
     form_label = _("Associated archaelogical sites")
     archaeological_sites = forms.IntegerField(
-        widget=widgets.JQueryAutoComplete(reverse_lazy(
-                    'autocomplete-archaeologicalsite'),
+        widget=widgets.JQueryAutoComplete(
+            reverse_lazy('autocomplete-archaeologicalsite'),
             associated_model=models.ArchaeologicalSite, new=True,
             multiple=True),
-            label=_(u"Search"))
+        label=_(u"Search"))
+
 
 class FinalOperationClosingForm(FinalForm):
     confirm_msg = " "
     confirm_end_msg = _(u"Would you like to close this operation?")
 
+
 class OperationDeletionForm(FinalForm):
     confirm_msg = " "
     confirm_end_msg = _(u"Would you like to delete this operation?")
@@ -842,10 +904,12 @@ class OperationDeletionForm(FinalForm):
 # Source management for operations #
 ####################################
 
+
 class OperationSourceForm(SourceForm):
     pk = forms.IntegerField(required=False, widget=forms.HiddenInput)
     index = forms.IntegerField(label=_(u"Index"))
-    hidden_operation_id = forms.IntegerField(label="", widget=forms.HiddenInput)
+    hidden_operation_id = forms.IntegerField(label="",
+                                             widget=forms.HiddenInput)
 
     def __init__(self, *args, **kwargs):
         super(OperationSourceForm, self).__init__(*args, **kwargs)
@@ -858,18 +922,20 @@ class OperationSourceForm(SourceForm):
         cleaned_data = self.cleaned_data
         operation_id = cleaned_data.get("hidden_operation_id")
         index = cleaned_data.get("index")
-        srcs = models.OperationSource.objects.filter(index=index,
-                                                     operation__pk=operation_id)
+        srcs = models.OperationSource.objects\
+                                     .filter(index=index,
+                                             operation__pk=operation_id)
         if 'pk' in cleaned_data and cleaned_data['pk']:
             srcs = srcs.exclude(pk=cleaned_data['pk'])
         if srcs.count():
-            max_val = models.OperationSource.objects.filter(
-                                                     operation__pk=operation_id
-                                   ).aggregate(Max('index'))["index__max"]
+            max_val = models.OperationSource.objects\
+                            .filter(operation__pk=operation_id)\
+                            .aggregate(Max('index'))["index__max"]
             operation = models.Operation.objects.get(pk=operation_id)
-            raise forms.ValidationError(_(u"Index already exists for "
-"operation: %(operation)s - use a value bigger than %(last_val)d") % {
-                    "operation":unicode(operation), 'last_val':max_val})
+            raise forms.ValidationError(
+                _(u"Index already exists for operation: %(operation)s - use a "
+                  u"value bigger than %(last_val)d") % {
+                    "operation": unicode(operation), 'last_val': max_val})
         return cleaned_data
 
 SourceOperationFormSelection = get_form_selection(
@@ -877,6 +943,7 @@ SourceOperationFormSelection = get_form_selection(
     models.Operation, OperationSelect, 'get-operation',
     _(u"You should select an operation."))
 
+
 class OperationSourceSelect(SourceSelect):
     operation__towns = get_town_field(label=_(u"Operation's town"))
     operation__operation_type = forms.ChoiceField(label=_(u"Operation type"),
@@ -886,9 +953,9 @@ class OperationSourceSelect(SourceSelect):
     def __init__(self, *args, **kwargs):
         super(OperationSourceSelect, self).__init__(*args, **kwargs)
         self.fields['operation__operation_type'].choices = \
-                                            models.OperationType.get_types()
+            models.OperationType.get_types()
         self.fields['operation__operation_type'].help_text = \
-                                            models.OperationType.get_help()
+            models.OperationType.get_help()
 
 
 OperationSourceFormSelection = get_form_selection(
@@ -900,6 +967,7 @@ OperationSourceFormSelection = get_form_selection(
 # Administrative act management for operations #
 ################################################
 
+
 class AdministrativeActOpeSelect(TableSelect):
     year = forms.IntegerField(label=_("Year"))
     index = forms.IntegerField(label=_("Index"))
@@ -909,50 +977,53 @@ class AdministrativeActOpeSelect(TableSelect):
     act_type = forms.ChoiceField(label=_("Act type"), choices=[])
     operation__towns = get_town_field()
     history_creator = forms.IntegerField(
-            label=_(u"Created by"),
-            widget=widgets.JQueryAutoComplete(
-                reverse_lazy('autocomplete-person',
-                args=['0', 'user']),
-                associated_model=Person),
-            validators=[valid_id(Person)])
+        label=_(u"Created by"),
+        widget=widgets.JQueryAutoComplete(
+            reverse_lazy('autocomplete-person', args=['0', 'user']),
+            associated_model=Person),
+        validators=[valid_id(Person)])
 
     def __init__(self, *args, **kwargs):
         super(AdministrativeActOpeSelect, self).__init__(*args, **kwargs)
         self.fields['act_type'].choices = models.ActType.get_types(
-                                                   dct={'intented_to':'O'})
+            dct={'intented_to': 'O'})
         self.fields['act_type'].help_text = models.ActType.get_help(
-                                                   dct={'intented_to':'O'})
+            dct={'intented_to': 'O'})
+
 
 class AdministrativeActOpeFormSelection(forms.Form):
     form_label = _("Administrative act search")
-    associated_models = {'pk':models.AdministrativeAct}
-    currents = {'pk':models.AdministrativeAct}
-    pk = forms.IntegerField(label="", required=False,
-       widget=widgets.JQueryJqGrid(reverse_lazy('get-administrativeactop'),
+    associated_models = {'pk': models.AdministrativeAct}
+    currents = {'pk': models.AdministrativeAct}
+    pk = forms.IntegerField(
+        label="", required=False,
+        widget=widgets.JQueryJqGrid(
+            reverse_lazy('get-administrativeactop'),
             AdministrativeActOpeSelect, models.AdministrativeAct,
             table_cols='TABLE_COLS_OPE'),
-       validators=[valid_id(models.AdministrativeAct)])
+        validators=[valid_id(models.AdministrativeAct)])
 
     def clean(self):
         cleaned_data = self.cleaned_data
         if 'pk' not in cleaned_data or not cleaned_data['pk']:
-            raise forms.ValidationError(_(u"You should select an administrative"
-                                           " act."))
+            raise forms.ValidationError(
+                _(u"You should select an administrative act."))
         return cleaned_data
 
+
 class AdministrativeActOpeForm(forms.Form):
     form_label = _("General")
-    associated_models = {'act_type':models.ActType,}
+    associated_models = {'act_type': models.ActType, }
     #                     'signatory':Person}
     act_type = forms.ChoiceField(label=_("Act type"), choices=[])
-    #signatory = forms.IntegerField(label=_("Signatory"),
+    # signatory = forms.IntegerField(label=_("Signatory"),
     #     widget=widgets.JQueryAutoComplete(reverse_lazy('autocomplete-person'),
     #                                 associated_model=Person, new=True),
     #     validators=[valid_id(Person)], required=False)
     act_object = forms.CharField(label=_(u"Object"), max_length=300,
                                  widget=forms.Textarea, required=False)
-    signature_date = forms.DateField(label=_(u"Signature date"),
-                                     initial=get_now, widget=widgets.JQueryDate)
+    signature_date = forms.DateField(
+        label=_(u"Signature date"), initial=get_now, widget=widgets.JQueryDate)
     if settings.COUNTRY == 'fr':
         ref_sra = forms.CharField(label=u"Autre référence", max_length=15,
                                   required=False)
@@ -960,14 +1031,16 @@ class AdministrativeActOpeForm(forms.Form):
     def __init__(self, *args, **kwargs):
         super(AdministrativeActOpeForm, self).__init__(*args, **kwargs)
         self.fields['act_type'].choices = models.ActType.get_types(
-                                                   dct={'intented_to':'O'})
+            dct={'intented_to': 'O'})
         self.fields['act_type'].help_text = models.ActType.get_help(
-                                                   dct={'intented_to':'O'})
+            dct={'intented_to': 'O'})
+
 
 class FinalAdministrativeActDeleteForm(FinalForm):
     confirm_msg = " "
     confirm_end_msg = _(u"Would you like to delete this administrative act?")
 
+
 class DocumentGenerationAdminActForm(forms.Form):
     _associated_model = models.AdministrativeAct
     document_template = forms.ChoiceField(label=_("Template"), choices=[])
@@ -981,23 +1054,23 @@ class DocumentGenerationAdminActForm(forms.Form):
             self.obj = kwargs.pop('obj')
         super(DocumentGenerationAdminActForm, self).__init__(*args, **kwargs)
         self.fields['document_template'].choices = DocumentTemplate.get_tuples(
-                    dct={'associated_object_name':
-                         'archaeological_operations.models.AdministrativeAct',
-                         'acttypes__intented_to':self.document_type})
+            dct={'associated_object_name':
+                 'archaeological_operations.models.AdministrativeAct',
+                 'acttypes__intented_to': self.document_type})
 
     def clean(self):
         if not self.obj:
-            raise forms.ValidationError(_(u"You should select an administrative"
-                                           " act."))
+            raise forms.ValidationError(
+                _(u"You should select an administrative act."))
         cleaned_data = self.cleaned_data
         try:
             dt = DocumentTemplate.objects.get(
-                    pk=self.cleaned_data['document_template'])
+                pk=self.cleaned_data['document_template'])
         except DocumentTemplate.DoesNotExist:
             raise forms.ValidationError(_(u"This document is not intended for "
                                           u"this type of act."))
-        if self.obj.act_type.pk not in [act_type.pk
-                                    for act_type in dt.acttypes.all()]:
+        if self.obj.act_type.pk not in [
+                act_type.pk for act_type in dt.acttypes.all()]:
             raise forms.ValidationError(_(u"This document is not intended for "
                                           u"this type of act."))
         return cleaned_data
@@ -1009,22 +1082,25 @@ class DocumentGenerationAdminActForm(forms.Form):
             return
         try:
             template = DocumentTemplate.objects.get(
-                            pk=self.cleaned_data.get('document_template'))
+                pk=self.cleaned_data.get('document_template'))
         except DocumentTemplate.DoesNotExist:
             return
         return template.publish(c_object)
 
+
 class GenerateDocForm(forms.Form):
     form_label = _("Doc generation")
-    doc_generation = forms.ChoiceField(required=False, choices=[],
-                        label=_(u"Generate the associated doc?"))
+    doc_generation = forms.ChoiceField(
+        required=False, choices=[], label=_(u"Generate the associated doc?"))
+
     def __init__(self, *args, **kwargs):
         choices = []
         if 'choices' in kwargs:
             choices = kwargs.pop('choices')
         super(GenerateDocForm, self).__init__(*args, **kwargs)
-        self.fields['doc_generation'].choices = [('', u'-'*9)] + \
-                [(choice.pk , unicode(choice)) for choice in choices]
+        self.fields['doc_generation'].choices = [('', u'-' * 9)] + \
+            [(choice.pk, unicode(choice)) for choice in choices]
+
 
 class AdministrativeActRegisterSelect(AdministrativeActOpeSelect):
     indexed = forms.NullBooleanField(label=_(u"Indexed?"))
@@ -1032,23 +1108,26 @@ class AdministrativeActRegisterSelect(AdministrativeActOpeSelect):
     def __init__(self, *args, **kwargs):
         super(AdministrativeActRegisterSelect, self).__init__(*args, **kwargs)
         self.fields['act_type'].choices = models.ActType.get_types(
-                                                           dct={'indexed':True})
+            dct={'indexed': True})
         self.fields['act_type'].help_text = models.ActType.get_help()
 
+
 class AdministrativeActRegisterFormSelection(forms.Form):
-    form_label = pgettext_lazy('admin act register',u"Register")
-    associated_models = {'pk':models.AdministrativeAct}
-    currents = {'pk':models.AdministrativeAct}
-    pk = forms.IntegerField(label="", required=False,
-       widget=widgets.JQueryJqGrid(reverse_lazy('get-administrativeact'),
+    form_label = pgettext_lazy('admin act register', u"Register")
+    associated_models = {'pk': models.AdministrativeAct}
+    currents = {'pk': models.AdministrativeAct}
+    pk = forms.IntegerField(
+        label="", required=False,
+        widget=widgets.JQueryJqGrid(
+            reverse_lazy('get-administrativeact'),
             AdministrativeActRegisterSelect, models.AdministrativeAct,
             table_cols='TABLE_COLS',
             source_full=reverse_lazy('get-administrativeact-full')),
-       validators=[valid_id(models.AdministrativeAct)])
+        validators=[valid_id(models.AdministrativeAct)])
 
     def clean(self):
         cleaned_data = self.cleaned_data
         if 'pk' not in cleaned_data or not cleaned_data['pk']:
-            raise forms.ValidationError(_(u"You should select an administrative"
-                                           " act."))
+            raise forms.ValidationError(
+                _(u"You should select an administrative act."))
         return cleaned_data