Typo

6 files changed, 203 insertions, 202 deletions

diff --git a/archaeological_context_records/tests.py b/archaeological_context_records/tests.py
index 449662b4a..cf117285d 100644
--- a/archaeological_context_records/tests.py
+++ b/archaeological_context_records/tests.py
@@ -215,10 +215,10 @@ class SerializationTest(GenericSerializationTest, ContextRecordInit, TestCase):
         ope1 = self.create_operation()[0]
         ope2 = self.create_operation()[1]
         cr = self.create_context_record(
-            data={"label": u"CR 1", "operation": ope1}
+            data={"label": "CR 1", "operation": ope1}
         )[0]
         cr2 = self.create_context_record(
-            data={"label": u"CR 2", "operation": ope2}
+            data={"label": "CR 2", "operation": ope2}
         )[1]
         dating = models.Dating.objects.create(
             period=models.Period.objects.all()[0],
@@ -304,7 +304,7 @@ class ExportTest(ContextRecordInit, TestCase):
         ope = self.create_operation()[0]
         ope.code_patriarche = "45000"
         ope.save()
-        cr = self.create_context_record(data={"label": u"CR 1"})[0]
+        cr = self.create_context_record(data={"label": "CR 1"})[0]
         c = Client()
         url = reverse('get-by-importer',
                       kwargs={'slug': 'ishtar-context-record',
@@ -330,8 +330,8 @@ class ContextRecordTest(ContextRecordInit, TestCase):
     def setUp(self):
         IshtarSiteProfile.objects.create()
         self.username, self.password, self.user = create_superuser()
-        self.create_context_record(data={"label": u"CR 1"})
-        self.create_context_record(data={"label": u"CR 2"})
+        self.create_context_record(data={"label": "CR 1"})
+        self.create_context_record(data={"label": "CR 2"})
 
         cr_1 = self.context_records[0]
         cr_2 = self.context_records[1]
@@ -345,7 +345,7 @@ class ContextRecordTest(ContextRecordInit, TestCase):
         cr = self.context_records[0]
         self.assertEqual(
             cr.external_id,
-            u"{}-{}".format(cr.parcel.external_id, cr.label))
+            "{}-{}".format(cr.parcel.external_id, cr.label))
 
     def test_lost_parcel_dont_delete_context_record(self):
         cr = self.create_context_record(force=True)[0]
@@ -550,8 +550,8 @@ class ContextRecordSearchTest(ContextRecordInit, TestCase, SearchText):
     def setUp(self):
         IshtarSiteProfile.objects.create()
         self.username, self.password, self.user = create_superuser()
-        self.create_context_record(data={"label": u"CR 1"})
-        self.create_context_record(data={"label": u"CR 2"})
+        self.create_context_record(data={"label": "CR 1"})
+        self.create_context_record(data={"label": "CR 2"})
 
         cr_1 = self.context_records[0]
         cr_2 = self.context_records[1]
@@ -581,7 +581,7 @@ class ContextRecordSearchTest(ContextRecordInit, TestCase, SearchText):
         child_town = self.create_towns(datas=data)[-1]
         base_town.children.add(child_town)
 
-        town_key = pgettext_lazy("key for text search", u"town")
+        town_key = pgettext_lazy("key for text search", "town")
 
         # simple search
         search = {town_key: base_town.cached_label}
@@ -656,7 +656,7 @@ class ContextRecordSearchTest(ContextRecordInit, TestCase, SearchText):
             right_record=first_ope,
             relation_type=rel_ope)
         rel_key = pgettext_lazy("key for text search",
-                                u"operation-relation-type")
+                                "operation-relation-type")
         response = c.get(reverse('get-contextrecord'),
                          {'operation__year': 2010,
                           rel_key: rel_ope.label})
@@ -803,11 +803,12 @@ class ContextRecordPermissionTest(ContextRecordInit, TestCase):
         self.operations += self.create_operation(self.alt_user, self.orgas[0])
         self.operations[1].towns.add(town)
 
-        self.create_context_record(user=self.user, data={"label": u"CR 1",
+        self.create_context_record(user=self.user,
+                                   data={"label": "CR 1",
                                          "operation": self.operations[0]})
         self.create_context_record(
             user=self.alt_user,
-            data={"label": u"CR 2", "operation": self.operations[1]})
+            data={"label": "CR 2", "operation": self.operations[1]})
         self.cr_1 = self.context_records[0]
         self.cr_2 = self.context_records[1]
 
@@ -875,8 +876,8 @@ class RecordRelationsTest(ContextRecordInit, TestCase):
 
     def setUp(self):
         # two different context records
-        self.create_context_record({"label": u"CR 1"})
-        self.create_context_record({"label": u"CR 2"})
+        self.create_context_record({"label": "CR 1"})
+        self.create_context_record({"label": "CR 2"})
 
     def test_relations(self):
         sym_rel_type = models.RelationType.objects.create(
@@ -1026,15 +1027,15 @@ class GraphGenerationTest(ContextRecordInit, TestCase):
             symmetrical=False, txt_idx='below', logical_relation='below')
         self.rel_type_above, __ = models.RelationType.objects.get_or_create(
             symmetrical=False, txt_idx='above', logical_relation='above')
-        self.create_context_record({"label": u"CR 1"})
-        self.create_context_record({"label": u"CR 2"})
-        self.create_context_record({"label": u"CR 3"})
-        self.create_context_record({"label": u"CR 4"})
-        self.create_context_record({"label": u"CR 1B"})
-        self.create_context_record({"label": u"CR 2B"})
-        self.create_context_record({"label": u"CR 3B"})
-        self.create_context_record({"label": u"CR 2C"})
-        self.create_context_record({"label": u"CR 2D"})
+        self.create_context_record({"label": "CR 1"})
+        self.create_context_record({"label": "CR 2"})
+        self.create_context_record({"label": "CR 3"})
+        self.create_context_record({"label": "CR 4"})
+        self.create_context_record({"label": "CR 1B"})
+        self.create_context_record({"label": "CR 2B"})
+        self.create_context_record({"label": "CR 3B"})
+        self.create_context_record({"label": "CR 2C"})
+        self.create_context_record({"label": "CR 2D"})
 
         cr_1 = self.context_records[0]
         self.cr_2 = cr_2 = self.context_records[1]
diff --git a/archaeological_files/tests.py b/archaeological_files/tests.py
index f55e4b955..1aab1b2c4 100644
--- a/archaeological_files/tests.py
+++ b/archaeological_files/tests.py
@@ -59,14 +59,14 @@ class FileTest(TestCase, FileInit):
     def test_external_id(self):
         self.assertEqual(
             self.item.external_id,
-            u"{}-{}".format(self.item.year,
-                            self.item.numeric_reference))
+            "{}-{}".format(self.item.year,
+                           self.item.numeric_reference))
 
     def test_cached_label(self):
         self.item = models.File.objects.get(pk=self.item.pk)
         # localisation fix
         lbls = []
-        for town_lbl in (u'No town', u'Pas de commune'):
+        for town_lbl in ('No town', 'Pas de commune'):
             lbls.append(settings.JOINT.join(
                 [town_lbl, self.item.external_id,
                  self.item.internal_reference]))
@@ -89,13 +89,13 @@ class FileTest(TestCase, FileInit):
         nb_hist = item.history.count()
         self.assertTrue(item.history.count() >= 1)
         base_label = item.internal_reference
-        item.internal_reference = u"Unité_Test"
+        item.internal_reference = "Unité_Test"
         item.history_modifier = self.user
         item.save()
         self.assertEqual(item.history.count(), nb_hist + 1)
         self.assertEqual(item.history.all()[1].internal_reference, base_label)
         item = models.File.objects.get(pk=self.item.pk)
-        item.internal_reference = u"Unité_Testée"
+        item.internal_reference = "Unité_Testée"
         item.history_modifier = self.user
         item.skip_history_when_saving = True
         item.save()
@@ -109,7 +109,7 @@ class FileTest(TestCase, FileInit):
         self.assertEqual(self.item.history_creator, self.o_user)
         altuser, created = User.objects.get_or_create(username='altusername')
         item = models.File.objects.get(pk=self.item.pk)
-        item.internal_reference = u"Unité_Test"
+        item.internal_reference = "Unité_Test"
         item.history_modifier = altuser
         item.save()
         self.assertEqual(item.history_creator, self.o_user)
@@ -121,7 +121,7 @@ class FileTest(TestCase, FileInit):
         """
         item = models.File.objects.get(pk=self.item.pk)
         nb_hist = item.history.count()
-        item.internal_reference = u"Unité_Test"
+        item.internal_reference = "Unité_Test"
         item.history_modifier = self.user
         item.save()
         self.assertEqual(item.history.count(), nb_hist + 1)
@@ -149,11 +149,11 @@ class FileTest(TestCase, FileInit):
                     [(j, []) for j in models.File.HISTORICAL_M2M]
                 )
             self.assertTrue(k in new_values,
-                            msg=u'%s not in new values' % k)
+                            msg='%s not in new values' % k)
             self.assertEqual(
                 new_values[k], initial_values[k],
-                msg=u"for %s: %s != %s" % (k, str(new_values[k]),
-                                           str(initial_values[k])))
+                msg="for %s: %s != %s" % (k, str(new_values[k]),
+                                          str(initial_values[k])))
 
     def testRESTGetFile(self):
         response = self.client.post(
@@ -173,8 +173,8 @@ class FileTest(TestCase, FileInit):
 
     def testRESTGetOldFile(self):
         initial_ref = self.item.internal_reference
-        new_ref = u"Unité_Test_old_file"
-        new_ref = initial_ref != new_ref and new_ref or new_ref + u"extra"
+        new_ref = "Unité_Test_old_file"
+        new_ref = initial_ref != new_ref and new_ref or new_ref + "extra"
         item = models.File.objects.get(pk=self.item.pk)
         item.internal_reference = new_ref
         item.history_modifier = self.user
diff --git a/archaeological_finds/tests.py b/archaeological_finds/tests.py
index 93548f8fc..2ef551253 100644
--- a/archaeological_finds/tests.py
+++ b/archaeological_finds/tests.py
@@ -132,10 +132,10 @@ class SerializationTest(GenericSerializationTest, FindInit, TestCase):
         ope1 = self.create_operation()[0]
         ope2 = self.create_operation()[1]
         cr = self.create_context_record(
-            data={"label": u"CR 1", "operation": ope1}
+            data={"label": "CR 1", "operation": ope1}
         )[0]
         cr2 = self.create_context_record(
-            data={"label": u"CR 2", "operation": ope2}
+            data={"label": "CR 2", "operation": ope2}
         )[1]
         self.create_finds(data_base={"context_record": cr})[0]
         self.create_finds(data_base={"context_record": cr2})[1]
@@ -555,14 +555,14 @@ class TreatmentWizardCreationTest(WizardTest, FindInit, TestCase):
                                loan.pk)
 
         planned, __ = models.TreatmentState.objects.get_or_create(
-            txt_idx='planned', defaults={"executed": False, "label": u"Planned"}
+            txt_idx='planned', defaults={"executed": False, "label": "Planned"}
         )
         planned.executed = False
         planned.save()
         self.form_datas[0].set('basetreatment', 'treatment_state', planned.pk)
 
         completed, created = models.TreatmentState.objects.get_or_create(
-            txt_idx='completed', defaults={"executed": True, "label": u"Done"}
+            txt_idx='completed', defaults={"executed": True, "label": "Done"}
         )
         completed.executed = True
         completed.save()
@@ -645,7 +645,7 @@ class ImportFindTest(ImportTest, FindInit, TestCase):
                                                            mcc_images.read())}
         post_dict = {'importer_type': MCC.pk, 'skip_lines': 1,
                      "encoding": 'utf-8', "name": 'init_find_import',
-                     "csv_sep": u","}
+                     "csv_sep": ","}
         form = forms_common.NewImportForm(data=post_dict, files=file_dict,
                                           user=self.user)
         form.is_valid()
@@ -855,12 +855,12 @@ class FindTest(FindInit, TestCase):
         base_find = find.base_finds.all()[0]
         self.assertEqual(
             find.external_id,
-            u"{}-{}".format(
+            "{}-{}".format(
                 find.get_first_base_find().context_record.external_id,
                 find.label))
         self.assertEqual(
             base_find.external_id,
-            u"{}-{}".format(
+            "{}-{}".format(
                 base_find.context_record.external_id,
                 base_find.label))
         base_find.label = "New label"
@@ -868,7 +868,7 @@ class FindTest(FindInit, TestCase):
         base_find = models.BaseFind.objects.get(pk=base_find.pk)
         self.assertEqual(
             base_find.external_id,
-            u"{}-{}".format(
+            "{}-{}".format(
                 base_find.context_record.external_id,
                 "New label"))
         cr = ContextRecord.objects.get(pk=base_find.context_record.pk)
@@ -894,28 +894,28 @@ class FindTest(FindInit, TestCase):
         find.save()
         find = models.Find.objects.get(pk=find.pk)
         # default: {get_first_base_find__context_record__external_id}-{label}
-        self.assertEqual(find.external_id, u"PAT-12345-A1-new-label-too-hop")
+        self.assertEqual(find.external_id, "PAT-12345-A1-new-label-too-hop")
         profile = get_current_profile(force=True)
         profile.find_external_id = \
-            u"{get_first_base_find__context_record__external_id}-{label}-"\
-            u"{label}"
+            "{get_first_base_find__context_record__external_id}-{label}-"\
+            "{label}"
         profile.save()
         find.save()
         find = models.Find.objects.get(pk=find.pk)
         self.assertEqual(find.external_id,
-                         u"PAT-12345-A1-new-label-too-hop-hop")
+                         "PAT-12345-A1-new-label-too-hop-hop")
         profile.find_external_id = \
-            u"{get_first_base_find__context_record__external_id}-{label}-" \
-            u"{label}||lower||deduplicate"
+            "{get_first_base_find__context_record__external_id}-{label}-" \
+            "{label}||lower||deduplicate"
         profile.save()
         find.save()
         find = models.Find.objects.get(pk=find.pk)
         self.assertEqual(find.external_id,
-                         u"pat-12345-a1-new-label-too-hop")
+                         "pat-12345-a1-new-label-too-hop")
 
     def testIndex(self):
         profile = get_current_profile()
-        profile.find_index = u"O"
+        profile.find_index = "O"
         profile.save()
         get_current_profile(force=True)
 
@@ -947,7 +947,7 @@ class FindTest(FindInit, TestCase):
         self.assertEqual(bf_3.index, 1)
 
         profile = get_current_profile(force=True)
-        profile.find_index = u"CR"
+        profile.find_index = "CR"
         profile.save()
         profile = get_current_profile(force=True)
 
@@ -1258,8 +1258,8 @@ class FindSearchTest(FindInit, TestCase, SearchText):
         find2.save()
 
         result = [
-            (u'{}="{}"'.format(loan_key, str(_(u"Yes"))), 0),
-            (u'{}="{}"'.format(loan_key, str(_(u"No"))), 2),
+            ('{}="{}"'.format(loan_key, str(_("Yes"))), 0),
+            ('{}="{}"'.format(loan_key, str(_("No"))), 2),
         ]
         self._test_search(c, result, context="All container in their "
                                              "reference location")
@@ -1267,8 +1267,8 @@ class FindSearchTest(FindInit, TestCase, SearchText):
         find2.save()
 
         result = [
-            (u'{}="{}"'.format(loan_key, str(_(u"Yes"))), 1),
-            (u'{}="{}"'.format(loan_key, str(_(u"No"))), 1),
+            ('{}="{}"'.format(loan_key, str(_("Yes"))), 1),
+            ('{}="{}"'.format(loan_key, str(_("No"))), 1),
         ]
         self._test_search(c, result, context="One container in his "
                                              "reference location")
@@ -1347,10 +1347,10 @@ class FindPermissionTest(FindInit, TestCase):
 
         self.create_context_record(
             user=self.user,
-            data={"label": u"CR 1", "operation": self.operations[0]})
+            data={"label": "CR 1", "operation": self.operations[0]})
         self.create_context_record(
             user=self.alt_user,
-            data={"label": u"CR 2", "operation": self.operations[1]})
+            data={"label": "CR 2", "operation": self.operations[1]})
         self.cr_1 = self.context_records[-2]
         self.cr_2 = self.context_records[-1]
 
@@ -1394,8 +1394,8 @@ class FindQATest(FindInit, TestCase):
     model = models.Find
 
     def setUp(self):
-        self.create_finds(data_base={"label": u"Find 1"}, force=True)
-        self.create_finds(data_base={"label": u"Find 2"}, force=True)
+        self.create_finds(data_base={"label": "Find 1"}, force=True)
+        self.create_finds(data_base={"label": "Find 2"}, force=True)
         self.username, self.password, self.user = create_superuser()
         self.alt_username, self.alt_password, self.alt_user = create_user()
         self.alt_user.user_permissions.add(Permission.objects.get(
@@ -1457,7 +1457,7 @@ class FindQATest(FindInit, TestCase):
 
     def test_bulk_update(self):
         c = Client()
-        pks = u"{}-{}".format(self.finds[0].pk, self.finds[1].pk)
+        pks = "{}-{}".format(self.finds[0].pk, self.finds[1].pk)
         response = c.get(reverse('find-qa-bulk-update', args=[pks]))
         self.assertRedirects(response, '/')
 
@@ -1473,10 +1473,10 @@ class FindQATest(FindInit, TestCase):
 
         find_0 = self.finds[0]
         find_1 = self.finds[1]
-        base_desc_0 = u"Base description 1"
+        base_desc_0 = "Base description 1"
         find_0.description = base_desc_0
         find_0.save()
-        base_desc_1 = u"Base description 2"
+        base_desc_1 = "Base description 2"
         find_1.description = base_desc_1
         find_1.save()
 
@@ -1485,7 +1485,7 @@ class FindQATest(FindInit, TestCase):
                          [dating.period.pk for dating in find_0.datings.all()])
         self.assertNotIn(period,
                          [dating.period.pk for dating in find_1.datings.all()])
-        extra_desc = u"Extra description"
+        extra_desc = "Extra description"
         response = c.post(
             reverse('find-qa-bulk-update-confirm', args=[pks]),
             {'qa_period': period, 'qa_description': extra_desc}
@@ -1497,9 +1497,9 @@ class FindQATest(FindInit, TestCase):
         self.assertIn(period,
                       [dating.period.pk for dating in find_1.datings.all()])
         self.assertEqual(models.Find.objects.get(pk=find_0.pk).description,
-                         base_desc_0 + u"\n" + extra_desc)
+                         base_desc_0 + "\n" + extra_desc)
         self.assertEqual(models.Find.objects.get(pk=find_1.pk).description,
-                         base_desc_1 + u"\n" + extra_desc)
+                         base_desc_1 + "\n" + extra_desc)
 
     def test_basket(self):
         find_0 = self.finds[0]
@@ -1562,7 +1562,7 @@ class FindQATest(FindInit, TestCase):
         c = Client()
         find_0 = self.finds[0]
         find_1 = self.finds[1]
-        pks = u"{}-{}".format(find_0.pk, find_1.pk)
+        pks = "{}-{}".format(find_0.pk, find_1.pk)
         url = reverse('find-qa-packaging', args=[pks])
         response = c.get(url)
         self.assertRedirects(response, '/')
@@ -1674,7 +1674,7 @@ class FindHistoryTest(FindInit, TestCase):
     model = models.Find
 
     def setUp(self):
-        self.create_finds(data_base={"label": u"Find 1"}, force=True)
+        self.create_finds(data_base={"label": "Find 1"}, force=True)
         self.username, self.password, self.user = create_superuser()
         self.client = Client()
         self.client.login(username=self.username, password=self.password)
@@ -1687,7 +1687,7 @@ class FindHistoryTest(FindInit, TestCase):
             'dating_type': DatingType.objects.get(
                 txt_idx='from_absolute_dating'),
             "quality": DatingQuality.objects.get(txt_idx='sure'),
-            "precise_dating": u"Blah !!!"
+            "precise_dating": "Blah !!!"
         }
         d1 = Dating.objects.create(**d1_attrs)
         d2_attrs = {
@@ -1816,9 +1816,9 @@ class FindHistoryTest(FindInit, TestCase):
         self.assertIn('class="card sheet"', content)
         self.assertIn(
             models.MaterialType.objects.get(txt_idx='ceramic').label, content,
-            msg=u"ceramic not found in historical sheet")
-        self.assertIn("5001", content, msg=u"5001 not found in historical "
-                                           u"sheet")
+            msg="ceramic not found in historical sheet")
+        self.assertIn("5001", content, msg="5001 not found in historical "
+                                           "sheet")
         self.assertIn(
             Period.objects.get(txt_idx='neolithic').label, content)
 
@@ -1874,8 +1874,8 @@ class TreatmentTest(FindInit, TestCase):
         img = os.path.join(temp_dir, 'ishtar-bg.jpg')
         shutil.copy2(base_img, img)
 
-        self.create_finds(data_base={"label": u"Find 1"}, force=True)
-        self.create_finds(data_base={"label": u"Find 2"}, force=True)
+        self.create_finds(data_base={"label": "Find 1"}, force=True)
+        self.create_finds(data_base={"label": "Find 2"}, force=True)
         image = Document.objects.create(title="Image!")
         image.image.save('ishtar-bg.jpg', File(open(img, "rb")))
         self.finds[0].documents.add(image)
@@ -1903,7 +1903,7 @@ class TreatmentTest(FindInit, TestCase):
         first_find = self.finds[0]
 
         completed, created = models.TreatmentState.objects.get_or_create(
-            txt_idx='completed', defaults={"executed": True, "label": u"Done"}
+            txt_idx='completed', defaults={"executed": True, "label": "Done"}
         )
         completed.executed = True
         completed.save()
@@ -1951,7 +1951,7 @@ class TreatmentTest(FindInit, TestCase):
 
         initial_find = self.finds[0]
         completed, created = models.TreatmentState.objects.get_or_create(
-            txt_idx='completed', defaults={"executed": True, "label": u"Done"}
+            txt_idx='completed', defaults={"executed": True, "label": "Done"}
         )
         completed.executed = True
         completed.save()
@@ -1987,7 +1987,7 @@ class TreatmentTest(FindInit, TestCase):
 
         initial_find = self.finds[0]
         completed, created = models.TreatmentState.objects.get_or_create(
-            txt_idx='completed', defaults={"executed": True, "label": u"Done"}
+            txt_idx='completed', defaults={"executed": True, "label": "Done"}
         )
         completed.executed = True
         completed.save()
@@ -2028,7 +2028,7 @@ class TreatmentTest(FindInit, TestCase):
 
         initial_find = self.finds[0]
         completed, created = models.TreatmentState.objects.get_or_create(
-            txt_idx='completed', defaults={"executed": True, "label": u"Done"}
+            txt_idx='completed', defaults={"executed": True, "label": "Done"}
         )
         completed.executed = True
         completed.save()
@@ -2062,7 +2062,7 @@ class GeomaticTest(FindInit, TestCase):
     model = models.Find
 
     def setUp(self):
-        self.create_finds(data_base={"label": u"Find 1"}, force=True)
+        self.create_finds(data_base={"label": "Find 1"}, force=True)
 
     def test_point_precision(self):
         self.username = 'myuser'
@@ -2429,7 +2429,7 @@ class PublicAPITest(FindInit, APITestCase):
     model = models.Find
 
     def setUp(self):
-        self.create_finds(data_base={"label": u"Find 1"}, force=True)
+        self.create_finds(data_base={"label": "Find 1"}, force=True)
         self.basket = models.FindBasket.objects.create(
             slug="my-basket", label="My basket",
             user=IshtarUser.objects.get(pk=self.get_default_user().pk))
diff --git a/archaeological_operations/tests.py b/archaeological_operations/tests.py
index 7ff7d87ac..287b01013 100644
--- a/archaeological_operations/tests.py
+++ b/archaeological_operations/tests.py
@@ -71,7 +71,7 @@ class FileInit(object):
         self.user.save()
         self.o_user, created = User.objects.get_or_create(username='ousername')
         person_type, created = PersonType.objects.get_or_create(
-            label=u'Test ' u'person type', txt_idx='test_person',
+            label='Test person type', txt_idx='test_person',
             available=True)
         self.extra_models['person_type'] = person_type
         self.model_list.append(person_type)
@@ -83,12 +83,12 @@ class FileInit(object):
         self.model_list.append(person)
 
         file_type, created = FileType.objects.get_or_create(
-            label=u'Test file type', txt_idx='test_file', available=True)
+            label='Test file type', txt_idx='test_file', available=True)
         self.extra_models['file_type'] = file_type
         self.model_list.append(file_type)
 
         dct = {'year': 2010, 'numeric_reference': 1000, 'file_type': file_type,
-               'internal_reference': u'UNIT_testÉ ?', 'in_charge': person,
+               'internal_reference': 'UNIT_testÉ ?', 'in_charge': person,
                'history_modifier': self.o_user, 'total_surface': 10000}
         self.item = File(**dct)
         self.item.save()
@@ -109,8 +109,8 @@ class ImportTest(object):
         tg.save()
 
     def init_ope_import(self, filename='MCC-operations-example.csv',
-                        sep=u","):
-        mcc_operation = ImporterType.objects.get(name=u"MCC - Opérations")
+                        sep=","):
+        mcc_operation = ImporterType.objects.get(name="MCC - Opérations")
         mcc_operation_file = open(
             settings.ROOT_PATH +
             '../archaeological_operations/tests/' + filename,
@@ -208,7 +208,7 @@ class ImportTest(object):
 
     def init_parcel_import(self):
         self.init_ope()
-        mcc_parcel = ImporterType.objects.get(name=u"MCC - Parcelles")
+        mcc_parcel = ImporterType.objects.get(name="MCC - Parcelles")
         mcc_file = open(
             settings.ROOT_PATH +
             '../archaeological_operations/tests/MCC-parcelles-example.csv',
@@ -217,7 +217,7 @@ class ImportTest(object):
                                                          mcc_file.read())}
         post_dict = {'importer_type': mcc_parcel.pk, 'skip_lines': 1,
                      "encoding": 'utf-8', "name": 'init_parcel_import',
-                     "csv_sep": u","}
+                     "csv_sep": ","}
         form = forms_common.NewImportForm(data=post_dict, files=file_dict,
                                           user=self.user)
         form.is_valid()
@@ -231,7 +231,7 @@ class ImportTest(object):
 
     def init_context_record_import(self):
         self.init_parcel()
-        mcc = ImporterType.objects.get(name=u"MCC - UE")
+        mcc = ImporterType.objects.get(name="MCC - UE")
         mcc_file = open(
             settings.ROOT_PATH +
             '../archaeological_context_records/tests/'
@@ -240,7 +240,7 @@ class ImportTest(object):
                                                          mcc_file.read())}
         post_dict = {'importer_type': mcc.pk, 'skip_lines': 1,
                      "encoding": 'utf-8', "name": 'init_context_record_import',
-                     'csv_sep': u","}
+                     'csv_sep': ","}
         form = forms_common.NewImportForm(data=post_dict, files=file_dict,
                                           user=self.user)
         form.is_valid()
@@ -294,7 +294,7 @@ class ImportOperationTest(ImportTest, TestCase):
         self.assertEqual(current_person_nb, first_person_nb + 1)
         # and well imported
         last_ope = models.Operation.objects.order_by('-pk').all()[0]
-        self.assertEqual(last_ope.name, u"Oppìdum de Paris")
+        self.assertEqual(last_ope.name, "Oppìdum de Paris")
         self.assertEqual(last_ope.code_patriarche, '4200')
         self.assertEqual(last_ope.operation_type.txt_idx, 'prog_excavation')
 
@@ -317,7 +317,7 @@ class ImportOperationTest(ImportTest, TestCase):
     def test_import_semi_colon_sep(self):
         first_ope_nb = models.Operation.objects.count()
         importer, form = self.init_ope_import(
-            'MCC-operations-example-semi-colon.csv', sep=u";")
+            'MCC-operations-example-semi-colon.csv', sep=";")
         self.assertTrue(form.is_valid())
         impt = form.save(self.ishtar_user)
         impt.initialize()
@@ -485,7 +485,7 @@ class ImportOperationTest(ImportTest, TestCase):
     def test_export_libreoffice_template(self):
         if not settings.USE_LIBREOFFICE:  # function not available
             return
-        mcc_operation = ImporterType.objects.get(name=u"MCC - Opérations")
+        mcc_operation = ImporterType.objects.get(name="MCC - Opérations")
         generated_file = mcc_operation.get_libreoffice_template()
         zip_file = zipfile.ZipFile(generated_file)
         self.assertIsNone(zip_file.testzip(), "Libreoffice template generated "
@@ -564,9 +564,9 @@ class ImportOperationTest(ImportTest, TestCase):
         self.init_ope_targetkey(imp=impt)
         impt.importation()
         ope1 = models.Operation.objects.get(code_patriarche='4200')
-        self.assertEqual(ope1.data, {u'autre_refs': {u'arbitraire': 789}})
+        self.assertEqual(ope1.data, {'autre_refs': {'arbitraire': 789}})
         ope2 = models.Operation.objects.get(code_patriarche='4201')
-        self.assertEqual(ope2.data, {u'autre_refs': {u'arbitraire': 456}})
+        self.assertEqual(ope2.data, {'autre_refs': {'arbitraire': 456}})
 
         # #4292: Import of new JSON fields erase all precedent JSON fields
         it.delete()
@@ -580,11 +580,11 @@ class ImportOperationTest(ImportTest, TestCase):
         self.init_ope_targetkey(imp=impt)
         impt.importation()
         ope1 = models.Operation.objects.get(code_patriarche='4200')
-        self.assertEqual(ope1.data, {u'autre_refs': {u'arbitraire': 789},
-                                     u"autre": 666})
+        self.assertEqual(ope1.data, {'autre_refs': {'arbitraire': 789},
+                                     "autre": 666})
         ope2 = models.Operation.objects.get(code_patriarche='4201')
-        self.assertEqual(ope2.data, {u'autre_refs': {u'arbitraire': 456},
-                                     u"autre": 333})
+        self.assertEqual(ope2.data, {'autre_refs': {'arbitraire': 456},
+                                     "autre": 333})
 
     def test_regexp(self):
         importer, form = self.init_ope_import("operations-with-json-fields.csv")
@@ -648,7 +648,7 @@ class ImportDocumentTest(ImportTest, TestCase):
         group, c = TargetKeyGroup.objects.get_or_create(name="My group")
         post_dict = {'importer_type': doc_import.pk, 'skip_lines': 1,
                      "encoding": 'utf-8', "name": 'init_ope_import',
-                     "associated_group": group.pk, "csv_sep": u","}
+                     "associated_group": group.pk, "csv_sep": ","}
         form = forms_common.NewImportForm(data=post_dict, files=file_dict,
                                           user=self.user)
         form.is_valid()
@@ -695,7 +695,7 @@ class ImportStepByStepTest(ImportTest, TestCase):
                       response.content.decode())
         # creation have been evaluated
         self.assertIn(
-            str(_(u"New objects will be created.")),
+            str(_("New objects will be created.")),
             response.content.decode('utf-8')
         )
 
@@ -725,7 +725,7 @@ class ImportStepByStepTest(ImportTest, TestCase):
         response = c.get(import_url)
         self.assertEqual(response.status_code, 200)
         self.assertIn(
-            str(_(u"This line have been already imported.")),
+            str(_("This line have been already imported.")),
             response.content.decode('utf-8')
         )
 
@@ -744,10 +744,10 @@ class ImportStepByStepTest(ImportTest, TestCase):
             "valid": "change-csv",
             "col-1": "4201",
             "col-2": "Bourgogne",
-            "col-3": u"Fouille programmée",
-            "col-4": u"Oppìdum de Paris 2",
-            "col-5": u"L'opérateur",
-            "col-6": u"",
+            "col-3": "Fouille programmée",
+            "col-4": "Oppìdum de Paris 2",
+            "col-5": "L'opérateur",
+            "col-6": "",
             "col-7": "2000/01/32",
             "col-8": "2002/12/31",
             "col-9": "Age du Fer",
@@ -761,8 +761,8 @@ class ImportStepByStepTest(ImportTest, TestCase):
             self.assertIn("2000/01/32", imported_line)
         # error detected on the source file
         error = str(_(
-            u"The following error(s) has been encountered while parsing "
-            u"the source file:")
+            "The following error(s) has been encountered while parsing "
+            "the source file:")
         )
         self.assertIn(error, response.content.decode('utf-8'))
 
@@ -943,30 +943,30 @@ class ParcelTest(ImportTest, TestCase):
         # default_town = Town.objects.create(numero_insee="12345",
         #                                    name="default_town")
         test_values = (
-            (u"1996 : XT:53,54,56,57,59,60,61,62",
+            ("1996 : XT:53,54,56,57,59,60,61,62",
              {1996: [
                  ("XT", "53"), ("XT", "54"), ("XT", "56"), ("XT", "57"),
                  ("XT", "59"), ("XT", "60"), ("XT", "61"), ("XT", "62"),
              ]}
              ),
-            (u"AD:23",
+            ("AD:23",
              {None: [
                  ("AD", "23")
              ]}),
-            (u"1961 :B1:227;",
+            ("1961 :B1:227;",
              {1961: [
                  ("B1", '227')
              ]}),
-            (u"1982 CV:35;CV:36",
+            ("1982 CV:35;CV:36",
              {1982: [
                  ("CV", "35"), ("CV", "36"),
              ]}),
-            (u"E:24;E:25",
+            ("E:24;E:25",
              {None: [
                  ("E", "24"), ("E", "25"),
              ]}),
-            (u"B : 375, 376, 386, 387, 645, 646 / C : 412 à 415, 432 à 435, "
-             u"622 / F : 120, 149, 150, 284, 287, 321 à 323",
+            ("B : 375, 376, 386, 387, 645, 646 / C : 412 à 415, 432 à 435, "
+             "622 / F : 120, 149, 150, 284, 287, 321 à 323",
              {None: [
                  ("B", "375"), ("B", "376"), ("B", "386"), ("B", "387"),
                  ("B", "645"), ("B", "646"),
@@ -976,7 +976,7 @@ class ParcelTest(ImportTest, TestCase):
                  ("F", "120"), ("F", "149"), ("F", "150"), ("F", "284"),
                  ("F", "287"), ("F", "321"), ("F", "322"), ("F", "323"),
              ]}),
-            (u"AD : 95, 96, 86, 87, 81, 252, AE : 58, AD : 115 à 132",
+            ("AD : 95, 96, 86, 87, 81, 252, AE : 58, AD : 115 à 132",
              {None: [
                  ("AD", "95"), ("AD", "96"), ("AD", "86"), ("AD", "87"),
                  ("AD", "81"), ("AD", "252"), ("AD", "115"), ("AD", "116"),
@@ -986,9 +986,9 @@ class ParcelTest(ImportTest, TestCase):
                  ("AD", "129"), ("AD", "130"), ("AD", "131"), ("AD", "132"),
                  ("AE", "58"),
              ]}),
-            (u"XD:1 à 13, 24 à 28, 33 à 39, 50 à 52, 80, 83, 84 à 86, 259 à "
-             u"261, 182, 225 ; XH:5 ; P:1640, 1888, 1889, 1890 ; R:1311, "
-             u"1312, 1314,1342, 1343, 1559 à 1569",
+            ("XD:1 à 13, 24 à 28, 33 à 39, 50 à 52, 80, 83, 84 à 86, 259 à "
+             "261, 182, 225 ; XH:5 ; P:1640, 1888, 1889, 1890 ; R:1311, "
+             "1312, 1314,1342, 1343, 1559 à 1569",
              {None: [
                  ('XD', "1"), ('XD', "2"), ('XD', "3"), ('XD', "4"),
                  ('XD', "5"), ('XD', "6"), ('XD', "7"), ('XD', "8"),
@@ -1006,7 +1006,7 @@ class ParcelTest(ImportTest, TestCase):
                  ("R", "1562"), ("R", "1563"), ("R", "1564"), ("R", "1565"),
                  ("R", "1566"), ("R", "1567"), ("R", "1568"), ("R", "1569"),
              ]}),
-            (u"BZ:2 à 5, 365 ; CD:88 à 104, 106, 108, 326",
+            ("BZ:2 à 5, 365 ; CD:88 à 104, 106, 108, 326",
              {None: [
                  ('BZ', '2'), ('BZ', '3'), ('BZ', '4'), ('BZ', '5'),
                  ('BZ', '365'), ('CD', '88'), ('CD', '89'), ('CD', '90'),
@@ -1016,8 +1016,8 @@ class ParcelTest(ImportTest, TestCase):
                  ('CD', '103'), ('CD', '104'), ('CD', '106'), ('CD', '326'),
                  ('CD', '108')
              ]}),
-            (u"AV 118 à 125, 127, 132 à 137, 153, 398p, 399, 402; BI 27, 30, "
-             u"32, 33, 188, 255, 256 à 258, 260, 284p, 294; BL 297",
+            ("AV 118 à 125, 127, 132 à 137, 153, 398p, 399, 402; BI 27, 30, "
+             "32, 33, 188, 255, 256 à 258, 260, 284p, 294; BL 297",
              {None: [
                  ('AV', '118'), ('AV', '119'), ('AV', '120'), ('AV', '121'),
                  ('AV', '122'), ('AV', '123'), ('AV', '124'), ('AV', '125'),
@@ -1029,27 +1029,27 @@ class ParcelTest(ImportTest, TestCase):
                  ('BI', '258'), ('BI', '260'), ('BI', '284p'), ('BI', '294'),
                  ('BL', '297'),
              ]}),
-            (u"A : 904 à 906, 911 ; E:40, 41",
+            ("A : 904 à 906, 911 ; E:40, 41",
              {None: [
                  ("A", '904'), ("A", '905'), ("A", '906'), ("A", '911'),
                  ("E", '40'), ("E", "41")
              ]}),
-            (u"1991 : BE:8, 12",
+            ("1991 : BE:8, 12",
              {"1991": [
                  ('BE', '8'), ('BE', '12'),
              ]}),
-            (u"1979 : EM:1",
+            ("1979 : EM:1",
              {"1979": [
                  ('EM', '1')
              ]},),
-            (u"B:448;B:449;B:450;B:451;B:452;B:455;B:456;B:457;B:458;B:459;"
-             u"B:1486;",
+            ("B:448;B:449;B:450;B:451;B:452;B:455;B:456;B:457;B:458;B:459;"
+             "B:1486;",
              {None: [
                  ("B", "448"), ("B", "449"), ("B", "450"), ("B", "451"),
                  ("B", "452"), ("B", "455"), ("B", "456"), ("B", "457"),
                  ("B", "458"), ("B", "459"), ("B", "1486"),
              ]}),
-            (u"AC : 72 à 81, 91 à 100, 197 / ZC:180 à 189",
+            ("AC : 72 à 81, 91 à 100, 197 / ZC:180 à 189",
              {None: [
                  ('AC', '72'), ('AC', '73'), ('AC', '74'), ('AC', '75'),
                  ('AC', '76'), ('AC', '77'), ('AC', '78'), ('AC', '79'),
@@ -1060,24 +1060,24 @@ class ParcelTest(ImportTest, TestCase):
                  ('ZC', '183'), ('ZC', '184'), ('ZC', '185'), ('ZC', '186'),
                  ('ZC', '187'), ('ZC', '188'), ('ZC', '189'),
              ]}),
-            (u"AB 37 et 308",
+            ("AB 37 et 308",
              {None: [
                  ('AB', '37'), ('AB', '308'),
              ]}),
-            (u"1983  D2 n° 458 et 459",
+            ("1983  D2 n° 458 et 459",
              {"1983": [
                  ('D2', '458'), ('D2', '459'),
              ]}),
-            (u"ZS : 21p, 66",
+            ("ZS : 21p, 66",
              {None: [
               ('ZS', '21p'), ('ZS', '66'),
               ]}),
-            (u"VV:166, 167, domaine public",
+            ("VV:166, 167, domaine public",
              {None: [
                  ('VV', '166'), ('VV', '167'),
              ]}),
-            (u" AS:13 à 15, 17 à 19, 21 à 32, 34 à 45, 47 à 53, 69, 70, 82, "
-             u"84 / CK:1, 24, 25, 29, 30, 37 à 43",
+            (" AS:13 à 15, 17 à 19, 21 à 32, 34 à 45, 47 à 53, 69, 70, 82, "
+             "84 / CK:1, 24, 25, 29, 30, 37 à 43",
              {None: [
               ("AS", "13"), ("AS", "14"), ("AS", "15"), ("AS", "17"),
               ("AS", "18"), ("AS", "19"), ("AS", "21"), ("AS", "22"),
@@ -1093,13 +1093,13 @@ class ParcelTest(ImportTest, TestCase):
               ('CK', "29"), ('CK', "30"), ('CK', "37"), ('CK', "38"),
               ('CK', "39"), ('CK', "40"), ('CK', "41"), ('CK', "42"),
               ('CK', "43"), ]}),
-            (u" ZN:37, 15, 35, 28, 29 / ZM:9, 73",
+            (" ZN:37, 15, 35, 28, 29 / ZM:9, 73",
              {None: [
                  ("ZN", "37"), ("ZN", "15"), ("ZN", "35"), ("ZN", "28"),
                  ("ZN", "29"), ("ZM", "9"), ("ZM", "73"),
              ]}),
-            (u" Tranche n°1 : YP:243, 12, 14 à 16, 18 à 26, DP / Tranche n°2 :"
-             u"YP:17, 307, 27, 308, 44 à 46, 683, BM:1, 250, 488 à 492",
+            (" Tranche n°1 : YP:243, 12, 14 à 16, 18 à 26, DP / Tranche n°2 :"
+             "YP:17, 307, 27, 308, 44 à 46, 683, BM:1, 250, 488 à 492",
              {None: [
                  ('YP', '243'), ('YP', '12'), ('YP', '14'), ('YP', '15'),
                  ('YP', '16'), ('YP', '18'), ('YP', '19'), ('YP', '20'),
@@ -1110,26 +1110,26 @@ class ParcelTest(ImportTest, TestCase):
                  ('BM', '488'), ('BM', '489'), ('BM', '490'), ('BM', '491'),
                  ('BM', '492'),
              ]}),
-            (u" H : 106, 156, 158",
+            (" H : 106, 156, 158",
              {None: [
                  ('H', '106'), ('H', '156'), ('H', '158'),
              ]}),
-            (u"Section YO : parcelles n° 19; 20",
+            ("Section YO : parcelles n° 19; 20",
              {None: [
                  ('YO', '19'), ('YO', '20'),
              ]}),
-            (u"1991 :AI:23;19;20;21;22;181;AM:116;214;215;233;235",
-             {u"1991": [
-                 (u"AI", "19"), (u"AI", "20"), (u"AI", "21"), (u"AI", "22"),
-                 (u"AI", "23"), (u"AI", "181"),
-                 (u"AM", "116"), (u"AM", "214"), (u"AM", "215"),
-                 (u"AM", "233"), (u"AM", "235"),
+            ("1991 :AI:23;19;20;21;22;181;AM:116;214;215;233;235",
+             {"1991": [
+                 ("AI", "19"), ("AI", "20"), ("AI", "21"), ("AI", "22"),
+                 ("AI", "23"), ("AI", "181"),
+                 ("AM", "116"), ("AM", "214"), ("AM", "215"),
+                 ("AM", "233"), ("AM", "235"),
              ]})
         )
-        # ),(u"Domaine public", {}
-        # ),(u"Tranche 1 : AV:4 à 6, 18, 80, 104 / partiellement : 5 et 18", {}
-        # ),(u" 1987 : ZD: ?", {}
-        # ),(u"A:26a, 26b, 27 / AB:95 / AK:4, 12, 20", {}
+        # ),("Domaine public", {}
+        # ),("Tranche 1 : AV:4 à 6, 18, 80, 104 / partiellement : 5 et 18", {}
+        # ),(" 1987 : ZD: ?", {}
+        # ),("A:26a, 26b, 27 / AB:95 / AK:4, 12, 20", {}
         for value, result in test_values:
             parcels = parse_parcels(value)
             if not parcels and not result:
@@ -1315,7 +1315,7 @@ class OperationTest(TestCase, OperationInitTest):
         parcel = self.get_default_parcel()
         parcel.operation = self.item
         parcel.save()
-        correct_ext_id = u"{}-{}-{}{}".format(
+        correct_ext_id = "{}-{}-{}{}".format(
             self.item.code_patriarche, parcel.town.numero_insee,
             parcel.section, parcel.parcel_number)
         self.assertEqual(parcel.external_id, correct_ext_id)
@@ -1442,9 +1442,9 @@ class OperationTest(TestCase, OperationInitTest):
         operation = models.Operation.objects.get(pk=operation.pk)
         operation.comment = "Zardoz"
         profile = get_current_profile()
-        profile.operation_region_code = u"42"
+        profile.operation_region_code = "42"
         profile.save()
-        operation.code_patriarche = u"42HUIAAA5"
+        operation.code_patriarche = "42HUIAAA5"
         operation.save()
         self.assertIsNotNone(operation.search_vector)
         for key in (
@@ -1645,7 +1645,7 @@ class OperationTest(TestCase, OperationInitTest):
     def test_json(self):
         operation = self.operations[0]
         operation.data = {"groundhog": {"number": 53444,
-                                        "awake_state": u"réveillée",
+                                        "awake_state": "réveillée",
                                         "with_feather": "Oui"},
                           "frog_number": 32303}
         operation.save()
@@ -1653,19 +1653,19 @@ class OperationTest(TestCase, OperationInitTest):
         content_type = ContentType.objects.get_for_model(operation)
         groundhog_section = JsonDataSection.objects.create(
             name="Marmotte", content_type=content_type)
-        JsonDataField.objects.create(name=u"État d'éveil",
+        JsonDataField.objects.create(name="État d'éveil",
                                      key='groundhog__awake_state',
                                      content_type=content_type,
                                      section=groundhog_section)
-        JsonDataField.objects.create(name=u"Avec plume",
+        JsonDataField.objects.create(name="Avec plume",
                                      key='groundhog__with_feather',
                                      content_type=content_type,
                                      section=groundhog_section)
-        JsonDataField.objects.create(name=u"Zzzzzzzz",
+        JsonDataField.objects.create(name="Zzzzzzzz",
                                      key='groundhog__zzz',
                                      content_type=content_type,
                                      section=groundhog_section)
-        JsonDataField.objects.create(name=u"Grenouille",
+        JsonDataField.objects.create(name="Grenouille",
                                      key='frog_number',
                                      content_type=content_type)
 
@@ -1693,16 +1693,16 @@ class OperationTest(TestCase, OperationInitTest):
     def test_json_search_vector_update(self):
         operation = self.operations[0]
         content_type = ContentType.objects.get_for_model(operation)
-        JsonDataField.objects.create(name=u"Nom de marmotte",
+        JsonDataField.objects.create(name="Nom de marmotte",
                                      key='groundhog__name',
                                      content_type=content_type,
                                      search_index=True)
-        JsonDataField.objects.create(name=u"Numéro grenouille",
+        JsonDataField.objects.create(name="Numéro grenouille",
                                      key='frog_number',
                                      content_type=content_type)
         operation = models.Operation.objects.get(pk=operation.pk)
-        operation.data = {"groundhog": {"name": u"La Marmotte héhé",
-                                        "color": u"Red"},
+        operation.data = {"groundhog": {"name": "La Marmotte héhé",
+                                        "color": "Red"},
                           "frog_number": 32303}
         operation.save()
         operation = models.Operation.objects.get(pk=operation.pk)
@@ -1883,14 +1883,14 @@ class CustomFormTest(TestCase, OperationInitTest):
     def test_json(self):
         operation = self.operations[0]
         operation.data = {"groundhog": {"number": 53444,
-                                        "awake_state": u"réveillée",
+                                        "awake_state": "réveillée",
                                         "with_feather": "Oui"},
                           "frog_number": 32303}
         operation.save()
 
         content_type = ContentType.objects.get_for_model(operation)
         field = JsonDataField.objects.create(
-            name=u"État d'éveil", key='groundhog__awake_state',
+            name="État d'éveil", key='groundhog__awake_state',
             content_type=content_type, value_type='C')
         form = CustomForm.objects.create(
             name="Test", form="operation-010-general", available=True,
@@ -1973,7 +1973,7 @@ class OperationSearchTest(TestCase, OperationInitTest, SearchText):
                          2)
         response = c.get(
             reverse('get-operation'),
-            {pgettext_lazy("key for text search", u"operator"):
+            {pgettext_lazy("key for text search", "operator"):
              self.orgas[0].name})
         result = json.loads(response.content.decode())
         self.assertEqual(result['recordsTotal'], 3)
@@ -1986,7 +1986,7 @@ class OperationSearchTest(TestCase, OperationInitTest, SearchText):
         c.login(username=self.username, password=self.password)
         # test vector search with accents
         operation = models.Operation.objects.get(pk=self.operations[0].pk)
-        operation.common_name = u"Opération : Château de Fougères"
+        operation.common_name = "Opération : Château de Fougères"
         operation.save()
         response = c.get(reverse('get-operation'), {'search_vector': 'chaTEAU'})
         result = json.loads(response.content.decode())
@@ -2006,12 +2006,12 @@ class OperationSearchTest(TestCase, OperationInitTest, SearchText):
         operation_1 = models.Operation.objects.get(pk=self.operations[0].pk)
         operation_2 = models.Operation.objects.get(pk=self.operations[1].pk)
         operation_3 = models.Operation.objects.get(pk=self.operations[2].pk)
-        operation_1.common_name = u"Opération : Château de Fougères"
+        operation_1.common_name = "Opération : Château de Fougères"
         operation_1.save()
-        operation_2.common_name = u"Opération : Fougère filicophyta et " \
-                                  u"herbe à chat"
+        operation_2.common_name = "Opération : Fougère filicophyta et " \
+                                  "herbe à chat"
         operation_2.save()
-        operation_3.common_name = u"Opération : Château Filicophyta"
+        operation_3.common_name = "Opération : Château Filicophyta"
         operation_3.save()
 
         # simple separation
@@ -2138,7 +2138,7 @@ class OperationSearchTest(TestCase, OperationInitTest, SearchText):
         self._test_search(c, result, context="Period open search")
         """
         self._test_search(c, search_period_q,
-                          u'{}*'.format(neo.label[:3]), 2, "Open search")
+                          '{}*'.format(neo.label[:3]), 2, "Open search")
                           """
 
         # non hierarchic search
@@ -2165,7 +2165,7 @@ class OperationSearchTest(TestCase, OperationInitTest, SearchText):
         c = Client()
         c.login(username=self.username, password=self.password)
 
-        search_year_q = str(pgettext("key for text search", u"year"))
+        search_year_q = str(pgettext("key for text search", "year"))
         q = '"chateau fougere" {}="2042"'.format(search_year_q)
         response = c.get(reverse('get-operation'), {'search_vector': q})
         result = json.loads(response.content.decode())
@@ -2188,7 +2188,7 @@ class OperationSearchTest(TestCase, OperationInitTest, SearchText):
         rel1, rel2 = self.create_relations()
         self.operations[1].year = 2011
         self.operations[1].save()
-        reltype_key = pgettext_lazy("key for text search", u"relation-types")
+        reltype_key = pgettext_lazy("key for text search", "relation-types")
         search = {
             'search_vector': 'year=2010 {}="{}"'.format(
                 reltype_key, rel2.name)
@@ -2391,7 +2391,7 @@ class OperationPermissionTest(TestCase, OperationInitTest):
         self.assertTrue(json.loads(response.content.decode()))
         self.assertEqual(json.loads(response.content.decode())['recordsTotal'],
                          1)
-        operator_key = pgettext_lazy("key for text search", u"operator")
+        operator_key = pgettext_lazy("key for text search", "operator")
         response = c.get(reverse('get-operation'),
                          {operator_key: self.orgas[0].name})
         self.assertEqual(json.loads(response.content.decode())['recordsTotal'],
@@ -2446,8 +2446,8 @@ class OperationPermissionTest(TestCase, OperationInitTest):
 
         profile_type = ProfileType.objects.get(txt_idx='collaborator')
         profile_type.groups.add(
-            Group.objects.get(name=u"Opérations rattachées : "
-                                   u"modification/suppression")
+            Group.objects.get(name="Opérations rattachées : "
+                                   "modification/suppression")
         )
 
         # area filter
@@ -3373,7 +3373,7 @@ class OperationQATest(OperationInitTest, TestCase):
     def test_lock(self):
         c = Client()
         op0, op1 = self.operations[0], self.operations[1]
-        pks = u"{}-{}".format(op0.pk, op1.pk)
+        pks = "{}-{}".format(op0.pk, op1.pk)
         url = reverse('operation-qa-lock', args=[pks])
 
         response = c.get(url)
@@ -3443,7 +3443,7 @@ class OperationQATest(OperationInitTest, TestCase):
 
     def test_bulk_update(self):
         c = Client()
-        pks = u"{}-{}".format(self.operations[0].pk, self.operations[1].pk)
+        pks = "{}-{}".format(self.operations[0].pk, self.operations[1].pk)
         response = c.get(reverse('operation-qa-bulk-update', args=[pks]))
         self.assertRedirects(response, '/')
 
@@ -3459,10 +3459,10 @@ class OperationQATest(OperationInitTest, TestCase):
 
         operation_0 = self.operations[0]
         operation_1 = self.operations[1]
-        base_desc_0 = u"Base description 1"
+        base_desc_0 = "Base description 1"
         operation_0.description = base_desc_0
         operation_0.save()
-        base_desc_1 = u"Base description 2"
+        base_desc_1 = "Base description 2"
         operation_1.description = base_desc_1
         operation_1.save()
 
@@ -3526,7 +3526,7 @@ class DocumentQATest(OperationInitTest, TestCase):
 
     def test_bulk_update(self):
         c = Client()
-        pks = u"{}-{}".format(self.source_1.pk, self.source_2.pk)
+        pks = "{}-{}".format(self.source_1.pk, self.source_2.pk)
         response = c.get(reverse('document-qa-bulk-update', args=[pks]))
         self.assertRedirects(response, '/')
 
diff --git a/archaeological_warehouse/tests.py b/archaeological_warehouse/tests.py
index 3a307b752..5ff09e202 100644
--- a/archaeological_warehouse/tests.py
+++ b/archaeological_warehouse/tests.py
@@ -48,10 +48,10 @@ class SerializationTest(GenericSerializationTest, FindInit, TestCase):
         ope1 = self.create_operation()[0]
         ope2 = self.create_operation()[1]
         cr = self.create_context_record(
-            data={"label": u"CR 1", "operation": ope1}
+            data={"label": "CR 1", "operation": ope1}
         )[0]
         cr2 = self.create_context_record(
-            data={"label": u"CR 2", "operation": ope2}
+            data={"label": "CR 2", "operation": ope2}
         )[1]
         self.create_finds(data_base={"context_record": cr})
         self.create_finds(data_base={"context_record": cr2})
diff --git a/ishtar_common/tests.py b/ishtar_common/tests.py
index 1b6889232..4356509e8 100644
--- a/ishtar_common/tests.py
+++ b/ishtar_common/tests.py
@@ -166,7 +166,7 @@ class UtilsTest(TestCase):
         data_1 = {
             'old':
                 {'youpi':
-                     {'plouf': u'tralalalère'}}
+                     {'plouf': 'tralalalère'}}
         }
         data_2 = {
             'tsoin_tsoin': 'hop',
@@ -177,7 +177,7 @@ class UtilsTest(TestCase):
             'tsoin_tsoin': 'hop',
             'old':
                 {'youpi':
-                     {'plouf': u'tralalalère'},
+                     {'plouf': 'tralalalère'},
                  'hoppy': 'hop'}
         }
         res = update_data(data_1, data_2)
@@ -185,13 +185,13 @@ class UtilsTest(TestCase):
 
     def test_move_dict_data(self):
         data = {
-            'old': {u'daté': "value"}
+            'old': {'daté': "value"}
         }
         expected = {
             'old': {'date': "value"}
         }
         res = move_dict_data(
-            data, u'data__old__daté', u"data__old__date")
+            data, 'data__old__daté', "data__old__date")
         self.assertEqual(res, expected)
         data = {
             '': {'hop': "value"}
@@ -200,12 +200,12 @@ class UtilsTest(TestCase):
             'hop': "value",
             '': {}
         }
-        res = move_dict_data(data, u'data____hop', u"data__hop")
+        res = move_dict_data(data, 'data____hop', "data__hop")
         self.assertEqual(res, expected)
         data = {
             'old': {
                   'traitement': {
-                      u'constat_état': 'aaa'
+                      'constat_état': 'aaa'
                   }
             }
         }
@@ -217,8 +217,8 @@ class UtilsTest(TestCase):
             }
         }
         res = move_dict_data(data,
-                             u'data__old__traitement__constat_état',
-                             u'data__old__traitement__constat_etat')
+                             'data__old__traitement__constat_état',
+                             'data__old__traitement__constat_etat')
         self.assertEqual(res, expected)
 
     def test_tinyfy_url(self):
@@ -2136,7 +2136,7 @@ class ShortMenuTest(TestCase):
     def _create_treatment(self):
         from archaeological_finds.models import Treatment, TreatmentState
         completed, created = TreatmentState.objects.get_or_create(
-            txt_idx='completed', defaults={"executed": True, "label": u"Done"}
+            txt_idx='completed', defaults={"executed": True, "label": "Done"}
         )
         return Treatment.objects.create(
             label="My treatment",
@@ -2291,12 +2291,12 @@ class ImportTest(TestCase):
             models.OrganizationType)
 
         # creation
-        label = u"Ploufé"
+        label = "Ploufé"
         ot = models.OrganizationType.objects.create(label=label)
         self.assertEqual(models.ItemKey.objects.filter(
                          object_id=ot.pk, key=slugify(label),
                          content_type=content_type).count(), 1)
-        label_2 = u"Plif"
+        label_2 = "Plif"
         ot_2 = models.OrganizationType.objects.create(label=label_2)
         self.assertEqual(models.ItemKey.objects.filter(
                          object_id=ot_2.pk, key=slugify(label_2),
@@ -2392,12 +2392,12 @@ class IshtarSiteProfileTest(TestCase):
     def testExternalKey(self):
         profile = models.get_current_profile()
         p = models.Person.objects.create(name='plouf', surname=u'Tégada')
-        self.assertEqual(p.raw_name, u"PLOUF Tégada")
-        profile.person_raw_name = u'{surname|slug} {name}'
+        self.assertEqual(p.raw_name, "PLOUF Tégada")
+        profile.person_raw_name = '{surname|slug} {name}'
         profile.save()
         p.raw_name = ''
         p.save()
-        self.assertEqual(p.raw_name, u"tegada plouf")
+        self.assertEqual(p.raw_name, "tegada plouf")
 
 
 class IshtarBasicTest(TestCase):
@@ -2610,8 +2610,8 @@ class CleanMedia(TestCase):
              "hoplala_gvK3hAr_2m7zZPn_nKhh2S2.jpg",),  # stop before because
             # another file exists
         ]
-        base_dir = os.sep.join([settings.ROOT_PATH, u"..", u"ishtar_common",
-                                u"tests", u"rename"])
+        base_dir = os.sep.join([settings.ROOT_PATH, "..", "ishtar_common",
+                                "tests", "rename"])
         for name, expected in test_names:
             name = os.sep.join([base_dir, name])
             new_name, modif = rename_and_simplify_media_name(name, rename=False)
@@ -2623,12 +2623,12 @@ class CleanMedia(TestCase):
 
     def test_try_fix(self):
         test_names = [
-            (u"hoplala_gvK3hAr_2m7zZPn_nKhh2S2_ZwWMKBd_ZwWMKBd.jpg",
+            ("hoplala_gvK3hAr_2m7zZPn_nKhh2S2_ZwWMKBd_ZwWMKBd.jpg",
              # non existing file
-             u"hoplala_gvK3hAr_2m7zZPn.jpg",),
+             "hoplala_gvK3hAr_2m7zZPn.jpg",),
         ]
-        base_dir = os.sep.join([settings.ROOT_PATH, u"..", u"ishtar_common",
-                                u"tests", u"rename"])
+        base_dir = os.sep.join([settings.ROOT_PATH, "..", "ishtar_common",
+                                "tests", "rename"])
         for name, expected in test_names:
             name = os.sep.join([base_dir, name])
 
@@ -2650,7 +2650,7 @@ class PersonQATest(TestCase):
 
     def test_bulk_update(self):
         c = Client()
-        pks = u"{}-{}".format(self.person_1.pk, self.person_2.pk)
+        pks = "{}-{}".format(self.person_1.pk, self.person_2.pk)
         response = c.get(reverse('person-qa-bulk-update', args=[pks]))
         self.assertRedirects(response, '/')