Flake8

1 files changed, 135 insertions, 110 deletions

diff --git a/ishtar_common/models.py b/ishtar_common/models.py
index d997d667d..8bdbd93ba 100644
--- a/ishtar_common/models.py
+++ b/ishtar_common/models.py
@@ -731,7 +731,8 @@ class DashboardFormItem(object):
         q = cls.objects.filter(**{date_var + '__isnull': False})
         if fltr:
             q = q.filter(**fltr)
-        q = q.filter(**{date_var + '__year': year, date_var + '__month': month})
+        q = q.filter(
+            **{date_var + '__year': year, date_var + '__month': month})
         return q.distinct('pk')
 
     @classmethod
@@ -1020,22 +1021,21 @@ class OrganizationType(GeneralType):
         ordering = ('label',)
 
 MODELS = [
-          ('archaeological_operations.models.Operation', _(u"Operation")),
-          ('archaeological_operations.models.Parcel', _(u"Parcels")),
-          ('archaeological_operations.models.OperationSource',
-                                                    _(u"Operation source")),
-          ]
+    ('archaeological_operations.models.Operation', _(u"Operation")),
+    ('archaeological_operations.models.Parcel', _(u"Parcels")),
+    ('archaeological_operations.models.OperationSource',
+     _(u"Operation source")),
+]
+
 if 'archaeological_files' in settings.INSTALLED_APPS:
-    MODELS = [('archaeological_files.models.File', _(u"Archaeological files")),
-             ] + MODELS
+    MODELS = [('archaeological_files.models.File', _(u"Archaeological files"))]\
+        + MODELS
 if 'archaeological_context_records' in settings.INSTALLED_APPS:
     MODELS = [('archaeological_context_records.models.ContextRecord',
-              _(u"Context records")),
-             ] + MODELS
+              _(u"Context records")), ] + MODELS
 if 'archaeological_finds' in settings.INSTALLED_APPS:
     MODELS = [('archaeological_finds.models.BaseFind',
-              _(u"Finds")),
-             ] + MODELS
+              _(u"Finds")), ] + MODELS
 
 
 def get_model_fields(model):
@@ -1069,10 +1069,11 @@ class ImporterType(models.Model):
     description = models.CharField(_(u"Description"), blank=True, null=True,
                                    max_length=500)
     users = models.ManyToManyField('IshtarUser', verbose_name=_(u"Users"),
-                                    blank=True, null=True)
-    associated_models = models.CharField(_(u"Associated model"), max_length=200,
-                                             choices=MODELS)
+                                   blank=True, null=True)
+    associated_models = models.CharField(_(u"Associated model"),
+                                         max_length=200, choices=MODELS)
     is_template = models.BooleanField(_(u"Is template"), default=False)
+
     class Meta:
         verbose_name = _(u"Importer - Type")
         verbose_name_plural = _(u"Importer - Types")
@@ -1083,7 +1084,7 @@ class ImporterType(models.Model):
     def get_importer_class(self):
         OBJECT_CLS = import_class(self.associated_models)
         DEFAULTS = dict([(default.keys, default.values)
-                                        for default in self.defaults.all()])
+                         for default in self.defaults.all()])
         LINE_FORMAT = []
         idx = 0
         for column in self.columns.order_by('col_number').all():
@@ -1106,17 +1107,18 @@ class ImporterType(models.Model):
             formater_kwargs = {}
             if column.regexp_pre_filter:
                 formater_kwargs['regexp'] = re.compile(
-                                                column.regexp_pre_filter.regexp)
-            formater_kwargs['duplicate_fields'] = [field.field_name
-                                     for field in column.duplicate_fields.all()]
+                    column.regexp_pre_filter.regexp)
+            formater_kwargs['duplicate_fields'] = [
+                field.field_name for field in column.duplicate_fields.all()]
             formater_kwargs['required'] = column.required
             formater = ImportFormater(targets, formater_types,
                                       **formater_kwargs)
             LINE_FORMAT.append(formater)
-        args = {'OBJECT_CLS':OBJECT_CLS, 'DESC':self.description,
-                'DEFAULTS':DEFAULTS, 'LINE_FORMAT':LINE_FORMAT}
-        name = str(''.join(x for x in slugify(self.name).replace('-', ' ').title()
-                       if not x.isspace()))
+        args = {'OBJECT_CLS': OBJECT_CLS, 'DESC': self.description,
+                'DEFAULTS': DEFAULTS, 'LINE_FORMAT': LINE_FORMAT}
+        name = str(''.join(
+            x for x in slugify(self.name).replace('-', ' ').title()
+            if not x.isspace()))
         newclass = type(name, (Importer,), args)
         return newclass
 
@@ -1147,6 +1149,7 @@ class ImporterDefault(models.Model):
     """
     importer_type = models.ForeignKey(ImporterType, related_name='defaults')
     target = models.CharField(u"Target", max_length=500)
+
     class Meta:
         verbose_name = _(u"Importer - Default")
         verbose_name_plural = _(u"Importer - Defaults")
@@ -1157,7 +1160,8 @@ class ImporterDefault(models.Model):
 
     @property
     def associated_model(self):
-        return get_associated_model(self.importer_type.associated_models, self.keys)
+        return get_associated_model(self.importer_type.associated_models,
+                                    self.keys)
 
     @property
     def values(self):
@@ -1175,6 +1179,7 @@ class ImporterDefaultValues(models.Model):
                                        related_name='default_values')
     target = models.CharField(u"Target", max_length=500)
     value = models.CharField(u"Value", max_length=500)
+
     class Meta:
         verbose_name = _(u"Importer - Default value")
         verbose_name_plural = _(u"Importer - Default values")
@@ -1213,6 +1218,7 @@ class ImporterColumn(models.Model):
     description = models.TextField(_("Description"), blank=True, null=True)
     regexp_pre_filter = models.ForeignKey("Regexp", blank=True, null=True)
     required = models.BooleanField(_(u"Required"), default=False)
+
     class Meta:
         verbose_name = _(u"Importer - Column")
         verbose_name_plural = _(u"Importer - Columns")
@@ -1225,6 +1231,7 @@ class ImporterDuplicateField(models.Model):
     column = models.ForeignKey(ImporterColumn, related_name='duplicate_fields')
     field_name = models.CharField(_(u"Field name"), blank=True, null=True,
                                   max_length=200)
+
     class Meta:
         verbose_name = _(u"Importer - Duplicate field")
         verbose_name_plural = _(u"Importer - Duplicate fields")
@@ -1235,6 +1242,7 @@ class Regexp(models.Model):
     description = models.CharField(_(u"Description"), blank=True, null=True,
                                    max_length=500)
     regexp = models.CharField(_(u"Regular expression"), max_length=500)
+
     class Meta:
         verbose_name = _(u"Importer - Regular expression")
         verbose_name_plural = _(u"Importer - Regular expressions")
@@ -1251,6 +1259,7 @@ class ImportTarget(models.Model):
     target = models.CharField(u"Target", max_length=500)
     regexp_filter = models.ForeignKey("Regexp", blank=True, null=True)
     formater_type = models.ForeignKey("FormaterType")
+
     class Meta:
         verbose_name = _(u"Importer - Target")
         verbose_name_plural = _(u"Importer - Targets")
@@ -1260,8 +1269,9 @@ class ImportTarget(models.Model):
 
     @property
     def associated_model(self):
-        return get_associated_model(self.column.importer_type.associated_models,
-                                    self.target.split('__'))
+        return get_associated_model(
+            self.column.importer_type.associated_models,
+            self.target.split('__'))
 
     def get_choices(self):
         if not self.associated_model or not hasattr(self.associated_model,
@@ -1305,14 +1315,13 @@ class TargetKey(models.Model):
             v = None
             # pk is given
             try:
-                pk = int(self.value)
                 v = self.target.associated_model.objects.get(
-                                                pk=unicode(self.value))
+                    pk=unicode(int(self.value)))
             except (ValueError, self.target.associated_model.DoesNotExist):
                 # try with txt_idx
                 try:
                     v = self.target.associated_model.objects.get(
-                                                    txt_idx=unicode(self.value))
+                        txt_idx=unicode(self.value))
                 except (self.target.associated_model.DoesNotExist):
                     pass
             if v:
@@ -1328,9 +1337,10 @@ TARGET_MODELS = [
     ('archaeological_operations.models.Period', _(u"Period")),
     ('archaeological_context_records.models.Unit', _(u"Unit")),
     ('archaeological_finds.models.MaterialType', _(u"Material")),
-    ('archaeological_finds.models.ConservatoryState', _(u"Conservatory state")),
+    ('archaeological_finds.models.ConservatoryState',
+     _(u"Conservatory state")),
     ('archaeological_finds.models.PreservationType', _(u"Preservation type")),
-    ]
+]
 
 TARGET_MODELS_KEYS = [tm[0] for tm in TARGET_MODELS]
 
@@ -1345,13 +1355,13 @@ IMPORTER_TYPES = (
 )
 
 IMPORTER_TYPES_DCT = {
-    'IntegerFormater':IntegerFormater,
-    'FloatFormater':FloatFormater,
-    'UnicodeFormater':UnicodeFormater,
-    'DateFormater':DateFormater,
-    'TypeFormater':TypeFormater,
-    'YearFormater':YearFormater,
-    'StrToBoolean':StrToBoolean,
+    'IntegerFormater': IntegerFormater,
+    'FloatFormater': FloatFormater,
+    'UnicodeFormater': UnicodeFormater,
+    'DateFormater': DateFormater,
+    'TypeFormater': TypeFormater,
+    'YearFormater': YearFormater,
+    'StrToBoolean': StrToBoolean,
 }
 
 DATE_FORMATS = (
@@ -1371,6 +1381,7 @@ class FormaterType(models.Model):
                                null=True)
     many_split = models.CharField(_(u"Split character(s)"), max_length=10,
                                   blank=True, null=True)
+
     class Meta:
         verbose_name = _(u"Importer - Formater type")
         verbose_name_plural = _(u"Importer - Formater types")
@@ -1378,10 +1389,11 @@ class FormaterType(models.Model):
         ordering = ('formater_type', 'options')
 
     def __unicode__(self):
-        return u" - ".join([unicode(dict(IMPORTER_TYPES)[self.formater_type])
-                          if self.formater_type in IMPORTER_TYPES_DCT else ''] +
-                        [getattr(self, k) for k in ('options', 'many_split')
-                                                        if getattr(self, k)])
+        return u" - ".join(
+            [unicode(dict(IMPORTER_TYPES)[self.formater_type])
+             if self.formater_type in IMPORTER_TYPES_DCT else ''] +
+            [getattr(self, k) for k in ('options', 'many_split')
+             if getattr(self, k)])
 
     def get_choices(self):
         if self.format_type in IMPORTER_TYPES_CHOICES:
@@ -1390,7 +1402,7 @@ class FormaterType(models.Model):
     def get_formater_type(self, target):
         if self.formater_type not in IMPORTER_TYPES_DCT.keys():
             return
-        kwargs = {'db_target':target}
+        kwargs = {'db_target': target}
         if self.many_split:
             kwargs['many_split'] = self.many_split
         if self.formater_type == 'TypeFormater':
@@ -1440,19 +1452,22 @@ class Import(models.Model):
                                 default='utf-8', max_length=15)
     skip_lines = models.IntegerField(_(u"Skip lines"), default=1)
     error_file = models.FileField(_(u"Error file"),
-                                     upload_to="upload/imports/",
-                                     blank=True, null=True)
+                                  upload_to="upload/imports/",
+                                  blank=True, null=True)
     result_file = models.FileField(_(u"Result file"),
-                                     upload_to="upload/imports/",
-                                     blank=True, null=True)
+                                   upload_to="upload/imports/",
+                                   blank=True, null=True)
     state = models.CharField(_(u"State"), max_length=2, choices=IMPORT_STATE,
                              default='C')
-    creation_date = models.DateTimeField(_(u"Creation date"), auto_now_add=True,
-                                         blank=True, null=True)
+    creation_date = models.DateTimeField(_(u"Creation date"),
+                                         auto_now_add=True, blank=True,
+                                         null=True)
     end_date = models.DateTimeField(_(u"End date"), blank=True,
                                     null=True, editable=False)
-    seconds_remaining = models.IntegerField(_(u"Seconds remaining"), blank=True,
-                                            null=True, editable=False)
+    seconds_remaining = models.IntegerField(_(u"Seconds remaining"),
+                                            blank=True, null=True,
+                                            editable=False)
+
     class Meta:
         verbose_name = _(u"Import")
         verbose_name_plural = _(u"Imports")
@@ -1496,7 +1511,7 @@ class Import(models.Model):
 
     def get_importer_instance(self):
         return self.importer_type.get_importer_class()(
-                        skip_lines=self.skip_lines, import_instance=self)
+            skip_lines=self.skip_lines, import_instance=self)
 
     @property
     def data_table(self):
@@ -1505,8 +1520,9 @@ class Import(models.Model):
             encodings += [coding for coding, c in ENCODINGS]
             for encoding in encodings:
                 try:
-                    return [line for line in unicodecsv.reader(csv_file,
-                                                       encoding=encoding)]
+                    return [line
+                            for line in unicodecsv.reader(csv_file,
+                                                          encoding=encoding)]
                 except UnicodeDecodeError:
                     if encoding != encodings[-1]:
                         csv_file.seek(0)
@@ -1526,7 +1542,7 @@ class Import(models.Model):
         importer.importation(self.data_table)
         # result file
         filename = slugify(self.importer_type.name)
-        now = datetime.datetime.now().isoformat('-').replace(':','')
+        now = datetime.datetime.now().isoformat('-').replace(':', '')
         result_file = filename + "_result_%s.csv" % now
         result_file = os.sep.join([self.result_file.storage.location,
                                    result_file])
@@ -1552,7 +1568,8 @@ class Import(models.Model):
 
     def get_all_imported(self):
         imported = []
-        for related, zorg in self._meta.get_all_related_m2m_objects_with_model():
+        for related, zorg in \
+                self._meta.get_all_related_m2m_objects_with_model():
             accessor = related.get_accessor_name()
             imported += [(accessor, obj)
                          for obj in getattr(self, accessor).all()]
@@ -1580,15 +1597,18 @@ class Organization(Address, Merge, OwnPerms, ValueGetter):
     organization_type = models.ForeignKey(OrganizationType,
                                           verbose_name=_(u"Type"))
     history = HistoricalRecords()
+
     class Meta:
         verbose_name = _(u"Organization")
         verbose_name_plural = _(u"Organizations")
         permissions = (
-          ("view_organization", ugettext(u"Can view all Organization")),
-          ("view_own_organization", ugettext(u"Can view own Organization")),
-          ("add_own_organization", ugettext(u"Can add own Organization")),
-          ("change_own_organization", ugettext(u"Can change own Organization")),
-          ("delete_own_organization", ugettext(u"Can delete own Organization")),
+            ("view_organization", ugettext(u"Can view all Organization")),
+            ("view_own_organization", ugettext(u"Can view own Organization")),
+            ("add_own_organization", ugettext(u"Can add own Organization")),
+            ("change_own_organization",
+             ugettext(u"Can change own Organization")),
+            ("delete_own_organization",
+             ugettext(u"Can delete own Organization")),
         )
 
     def __unicode__(self):
@@ -1605,30 +1625,31 @@ class Organization(Address, Merge, OwnPerms, ValueGetter):
     @property
     def associated_filename(self):
         values = [unicode(getattr(self, attr))
-                   for attr in ('organization_type', 'name')
-                               if getattr(self, attr)]
+                  for attr in ('organization_type', 'name')
+                  if getattr(self, attr)]
         return slugify(u"-".join(values))
 
 
 class PersonType(GeneralType):
-    #rights = models.ManyToManyField(WizardStep, verbose_name=_(u"Rights"))
+    # rights = models.ManyToManyField(WizardStep, verbose_name=_(u"Rights"))
     groups = models.ManyToManyField(Group, verbose_name=_(u"Groups"),
                                     blank=True, null=True)
+
     class Meta:
         verbose_name = _(u"Person type")
         verbose_name_plural = _(u"Person types")
         ordering = ('label',)
 
 
-class Person(Address, Merge, OwnPerms, ValueGetter) :
+class Person(Address, Merge, OwnPerms, ValueGetter):
     _prefix = 'person_'
     TYPE = (
-            ('Mr', _(u'Mr')),
-            ('Ms', _(u'Miss')),
-            ('Mr and Miss', _(u'Mr and Miss')),
-            ('Md', _(u'Mrs')),
-            ('Dr', _(u'Doctor')),
-            )
+        ('Mr', _(u'Mr')),
+        ('Ms', _(u'Miss')),
+        ('Mr and Miss', _(u'Mr and Miss')),
+        ('Md', _(u'Mrs')),
+        ('Dr', _(u'Doctor')),
+    )
     TABLE_COLS = ('name', 'surname', 'email', 'person_types_list',
                   'attached_to')
     title = models.CharField(_(u"Title"), max_length=2, choices=TYPE,
@@ -1636,13 +1657,13 @@ class Person(Address, Merge, OwnPerms, ValueGetter) :
     surname = models.CharField(_(u"Surname"), max_length=50, blank=True,
                                null=True)
     name = models.CharField(_(u"Name"), max_length=200, blank=True,
-                               null=True)
+                            null=True)
     raw_name = models.CharField(_(u"Raw name"), max_length=300, blank=True,
-                               null=True)
+                                null=True)
     person_types = models.ManyToManyField(PersonType, verbose_name=_(u"Types"))
-    attached_to = models.ForeignKey('Organization', related_name='members',
-                       on_delete=models.SET_NULL,
-                       verbose_name=_(u"Is attached to"), blank=True, null=True)
+    attached_to = models.ForeignKey(
+        'Organization', related_name='members', on_delete=models.SET_NULL,
+        verbose_name=_(u"Is attached to"), blank=True, null=True)
 
     class Meta:
         verbose_name = _(u"Person")
@@ -1656,9 +1677,8 @@ class Person(Address, Merge, OwnPerms, ValueGetter) :
         )
 
     def __unicode__(self):
-        values = [unicode(getattr(self, attr))
-                   for attr in ('surname', 'name')
-                               if getattr(self, attr)]
+        values = [unicode(getattr(self, attr)) for attr in ('surname', 'name')
+                  if getattr(self, attr)]
         if not values and self.raw_name:
             values = [self.raw_name]
         if self.attached_to:
@@ -1674,21 +1694,23 @@ class Person(Address, Merge, OwnPerms, ValueGetter) :
         TYPES = dict(self.TYPE)
         if self.title in TYPES:
             title = dict(self.TYPE)[self.title]
-        values[prefix+'title'] = title
+        values[prefix + 'title'] = title
         if not self.attached_to:
-            values.update(Person.get_empty_values(prefix=prefix + 'attached_to_'))
+            values.update(
+                Person.get_empty_values(prefix=prefix + 'attached_to_'))
         return values
 
     person_types_list_lbl = _(u"Types")
+
     @property
     def person_types_list(self):
         return u", ".join([unicode(pt) for pt in self.person_types.all()])
 
     def generate_merge_key(self):
         if self.name and self.name.strip():
-            self.merge_key = slugify(self.name.strip()) + (
-                                (u'-' + slugify(self.surname.strip()))
-                                                    if self.surname else u'')
+            self.merge_key = slugify(self.name.strip()) + \
+                ((u'-' + slugify(self.surname.strip()))
+                 if self.surname else u'')
         elif self.raw_name and self.raw_name.strip():
             self.merge_key = slugify(self.raw_name.strip())
         elif self.attached_to:
@@ -1707,13 +1729,13 @@ class Person(Address, Merge, OwnPerms, ValueGetter) :
             right_name = right_name.split('.')[-1]
         if type(right_name) in (list, tuple):
             return bool(self.person_types.filter(
-                                           txt_idx__in=right_name).count()) or \
-                   bool(self.person_types.filter(
+                txt_idx__in=right_name).count()) or \
+                bool(self.person_types.filter(
                      groups__permissions__codename__in=right_name).count())
         # or self.person_types.filter(wizard__url_name__in=right_name).count())
         return bool(self.person_types.filter(txt_idx=right_name).count()) or \
-               bool(self.person_types.filter(
-                     groups__permissions__codename=right_name).count())
+            bool(self.person_types.filter(
+                 groups__permissions__codename=right_name).count())
         # or self.person_types.filter(wizard__url_name=right_name).count())
 
     def full_label(self):
@@ -1721,8 +1743,7 @@ class Person(Address, Merge, OwnPerms, ValueGetter) :
         if self.title:
             values = [unicode(_(self.title))]
         values += [unicode(getattr(self, attr))
-                   for attr in ('surname', 'name')
-                               if getattr(self, attr)]
+                   for attr in ('surname', 'name') if getattr(self, attr)]
         if not values and self.raw_name:
             values = [self.raw_name]
         if self.attached_to:
@@ -1732,18 +1753,18 @@ class Person(Address, Merge, OwnPerms, ValueGetter) :
     @property
     def associated_filename(self):
         values = [unicode(getattr(self, attr))
-                   for attr in ('surname', 'name', 'attached_to')
-                               if getattr(self, attr)]
+                  for attr in ('surname', 'name', 'attached_to')
+                  if getattr(self, attr)]
         return slugify(u"-".join(values))
 
     def save(self, *args, **kwargs):
         super(Person, self).save(*args, **kwargs)
         if hasattr(self, 'responsible_town_planning_service'):
             for fle in self.responsible_town_planning_service.all():
-                fle.save() # force update of raw_town_planning_service
+                fle.save()  # force update of raw_town_planning_service
         if hasattr(self, 'general_contractor'):
             for fle in self.general_contractor.all():
-                fle.save() # force update of raw_general_contractor
+                fle.save()  # force update of raw_general_contractor
 
 
 class IshtarUser(User):
@@ -1763,11 +1784,11 @@ class IshtarUser(User):
         person_type = None
         if user.is_superuser:
             ADMINISTRATOR, created = PersonType.objects.get_or_create(
-                                            txt_idx='administrator')
+                txt_idx='administrator')
             person_type = ADMINISTRATOR
         else:
             person_type, created = PersonType.objects.get_or_create(
-                                                txt_idx='public_access')
+                txt_idx='public_access')
         person = Person.objects.create(title='Mr', surname=surname,
                                        name=name, email=email,
                                        history_modifier=user)
@@ -1776,7 +1797,7 @@ class IshtarUser(User):
                                          person=person)
 
     def has_right(self, right_name):
-       return self.person.has_right(right_name)
+        return self.person.has_right(right_name)
 
     def full_label(self):
         return self.person.full_label()
@@ -1798,13 +1819,14 @@ class Author(models.Model):
         verbose_name_plural = _(u"Authors")
 
     def __unicode__(self):
-        return unicode(self.person) + settings.JOINT + unicode(self.author_type)
+        return unicode(self.person) + settings.JOINT + \
+            unicode(self.author_type)
 
     def related_sources(self):
         return list(self.treatmentsource_related.all()) + \
-               list(self.operationsource_related.all()) + \
-               list(self.findsource_related.all()) + \
-               list(self.contextrecordsource_related.all())
+            list(self.operationsource_related.all()) + \
+            list(self.findsource_related.all()) + \
+            list(self.contextrecordsource_related.all())
 
 
 class SourceType(GeneralType):
@@ -1833,17 +1855,18 @@ class Source(models.Model):
     support_type = models.ForeignKey(SupportType, verbose_name=_(u"Support"),
                                      blank=True, null=True,)
     format_type = models.ForeignKey(Format, verbose_name=_(u"Format"),
-                                     blank=True, null=True,)
+                                    blank=True, null=True,)
     scale = models.CharField(_(u"Scale"), max_length=30, null=True,
                              blank=True)
     authors = models.ManyToManyField(Author, verbose_name=_(u"Authors"),
-                                 related_name="%(class)s_related")
-    associated_url = models.URLField(verify_exists=False, blank=True, null=True,
-                           verbose_name=_(u"Numerical ressource (web address)"))
+                                     related_name="%(class)s_related")
+    associated_url = models.URLField(
+        verify_exists=False, blank=True, null=True,
+        verbose_name=_(u"Numerical ressource (web address)"))
     receipt_date = models.DateField(blank=True, null=True,
                                     verbose_name=_(u"Receipt date"))
     creation_date = models.DateField(blank=True, null=True,
-                                    verbose_name=_(u"Creation date"))
+                                     verbose_name=_(u"Creation date"))
     item_number = models.IntegerField(_(u"Item number"), default=1)
     reference = models.CharField(_(u"Ref."), max_length=25, null=True,
                                  blank=True)
@@ -1853,7 +1876,7 @@ class Source(models.Model):
     comment = models.TextField(_(u"Comment"), blank=True, null=True)
     additional_information = models.TextField(_(u"Additional information"),
                                               blank=True, null=True)
-    TABLE_COLS = ['title', 'source_type', 'authors',]
+    TABLE_COLS = ['title', 'source_type', 'authors', ]
 
     class Meta:
         abstract = True
@@ -1873,8 +1896,10 @@ if settings.COUNTRY == 'fr':
         name = models.CharField(u"Nom", max_length=30)
         arrondissement = models.ForeignKey(Arrondissement,
                                            verbose_name=u"Arrondissement")
+
         def __unicode__(self):
-            return settings.JOINT.join((self.name, unicode(self.arrondissement)))
+            return settings.JOINT.join(
+                (self.name, unicode(self.arrondissement)))
 
 
 class Town(models.Model):
@@ -1885,8 +1910,8 @@ class Town(models.Model):
     if settings.COUNTRY == 'fr':
         numero_insee = models.CharField(u"Numéro INSEE", max_length=6,
                                         unique=True)
-        departement = models.ForeignKey(Department, verbose_name=u"Département",
-                                       null=True, blank=True)
+        departement = models.ForeignKey(
+            Department, verbose_name=u"Département", null=True, blank=True)
         canton = models.ForeignKey(Canton, verbose_name=u"Canton", null=True,
                                    blank=True)
     objects = models.GeoManager()