try to make pylint happy

dav_auth/__init__.py

@@ -1 +1 @@
-default_app_config = 'dav_auth.apps.AppConfig'
+default_app_config = 'dav_auth.apps.AppConfig'  # pylint: disable=invalid-name

dav_auth/apps.py

@@ -8,5 +8,5 @@ DEFAULT_SETTINGS = (
 
 class AppConfig(_AppConfig):
     name = 'dav_auth'
-    verbose_name = u'DAV Benutzerverwaltung'
+    verbose_name = 'DAV Benutzerverwaltung'
     default_settings = DEFAULT_SETTINGS

dav_auth/emails.py

@@ -2,8 +2,8 @@
 from dav_base.emails import AbstractMail
 
 
-class PasswordSetEmail(AbstractMail):
-    _subject = u'Zugangsdaten'
+class PasswordSetEmail(AbstractMail):  # pylint: disable=too-few-public-methods
+    _subject = 'Zugangsdaten'
     _template_name = 'dav_auth/emails/password_set.txt'
 
     def __init__(self, user, password):
@@ -11,12 +11,12 @@ class PasswordSetEmail(AbstractMail):
         self._password = password
 
     def _get_recipients(self):
-        r = u'"{fullname}" <{email}>'.format(fullname=self._user.get_full_name(),
+        r = '"{fullname}" <{email}>'.format(fullname=self._user.get_full_name(),
                                              email=self._user.email)
         return [r]
 
     def _get_context_data(self, extra_context=None):
-        context = super(PasswordSetEmail, self)._get_context_data(extra_context=extra_context)
+        context = super()._get_context_data(extra_context=extra_context)
         context.update({
             'fullname': self._user.get_full_name(),
             'username': self._user.username,

dav_auth/forms.py

@@ -9,13 +9,13 @@ logger = logging.getLogger(__name__)
 
 class LoginForm(auth_forms.AuthenticationForm):
     username = auth_forms.UsernameField(
-        label=_(u'E-Mail-Adresse'),
+        label=_('E-Mail-Adresse'),
         widget=forms.TextInput(attrs={'autofocus': True}),
     )
 
     error_messages = {
-        'invalid_login': _(u'Benutzername oder Passwort falsch.'),
-        'inactive': _("This account is inactive."),
+        'invalid_login': _('Benutzername oder Passwort falsch.'),
+        'inactive': _('This account is inactive.'),
     }
 
     def clean_username(self):
@@ -24,18 +24,18 @@ class LoginForm(auth_forms.AuthenticationForm):
 
 
 class SetPasswordForm(forms.Form):
-    new_password = forms.CharField(label=_(u'Neues Passwort'),
+    new_password = forms.CharField(label=_('Neues Passwort'),
                                    widget=forms.PasswordInput)
-    new_password_repeat = forms.CharField(label=_(u'Neues Passwort wiederholen'),
+    new_password_repeat = forms.CharField(label=_('Neues Passwort wiederholen'),
                                           widget=forms.PasswordInput)
     send_password_mail = forms.BooleanField(required=False,
                                             initial=False,
-                                            label=_(u'Neues Passwort per E-Mail zusenden'),
+                                            label=_('Neues Passwort per E-Mail zusenden'),
                                             )
 
     def __init__(self, user, *args, **kwargs):
         self.user = user
-        super(SetPasswordForm, self).__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)
 
     def clean_new_password(self):
         password = self.cleaned_data.get('new_password')
@@ -48,7 +48,7 @@ class SetPasswordForm(forms.Form):
         if password1 and password2:
             if password1 != password2:
                 raise forms.ValidationError(
-                    ugettext(u'Passwörter stimmen nicht überein'),
+                    ugettext('Passwörter stimmen nicht überein'),
                     code='password_mismatch',
                 )
         return password2
@@ -63,7 +63,7 @@ class SetPasswordForm(forms.Form):
 
 class CreateAndSendPasswordForm(forms.Form):
     username = auth_forms.UsernameField(
-        label=_(u'E-Mail-Adresse'),
+        label=_('E-Mail-Adresse'),
         widget=forms.TextInput(attrs={'autofocus': True}),
     )
 

dav_auth/tests/test_emails.py

@@ -9,10 +9,10 @@ from ..emails import PasswordSetEmail
 
 
 TEST_USERNAME = 'user'
-TEST_PASSWORD = u'me||ön 21ABll'
+TEST_PASSWORD = 'me||ön 21ABll'
 TEST_EMAIL = 'root@localhost'
 
-PASSWORD_EMAIL_TEMPLATE = u"""Hallo {fullname},
+PASSWORD_EMAIL_TEMPLATE = """Hallo {fullname},
 
 Benutzername: {username}
 Passwort:     {password}
@@ -23,7 +23,7 @@ URL:          {base_url}/
 
 class EmailTestCase(EmailTestMixin, TestCase):
     def setUp(self):
-        super(EmailTestCase, self).setUp()
+        super().setUp()
         model = get_user_model()
         self.user = model.objects.create_user(username=TEST_USERNAME, password=TEST_PASSWORD, email=TEST_EMAIL)
 
@@ -38,7 +38,7 @@ class EmailTestCase(EmailTestMixin, TestCase):
 
         self.assertSender(mail)
         self.assertRecipients(mail, [self.user])
-        self.assertSubject(mail, u'Zugangsdaten')
+        self.assertSubject(mail, 'Zugangsdaten')
 
         expected_body = PASSWORD_EMAIL_TEMPLATE.format(
             fullname=self.user.get_full_name(),

dav_auth/tests/test_forms.py

@@ -9,7 +9,7 @@ from dav_base.tests.generic import FormDataSet, FormsTestCase
 from ..forms import LoginForm, SetPasswordForm, CreateAndSendPasswordForm
 
 TEST_USERNAME = 'root@localhost'
-TEST_PASSWORD = u'me||ön 21ABll'
+TEST_PASSWORD = 'me||ön 21ABll'
 TEST_EMAIL = TEST_USERNAME
 
 
@@ -25,8 +25,8 @@ class LoginFormTestCase(FormsTestCase):
 
     def test_labels(self):
         form = self.form_class()
-        self.assertEqual(form.fields['username'].label, ugettext(u'E-Mail-Adresse'))
-        self.assertEqual(form.fields['password'].label, ugettext(u'Password'))
+        self.assertEqual(form.fields['username'].label, ugettext('E-Mail-Adresse'))
+        self.assertEqual(form.fields['password'].label, ugettext('Password'))
 
     def test_required(self):
         form = self.form_class()
@@ -38,28 +38,28 @@ class LoginFormTestCase(FormsTestCase):
             FormDataSet({'username': '', 'password': self.test_password},
                         expected_errors=[('username', 'required')]),
         ]
-        super(LoginFormTestCase, self).test_invalid_data(data_sets=data_sets)
+        super().test_invalid_data(data_sets=data_sets)
 
     def test_password_empty(self):
         data_sets = [
             FormDataSet({'username': self.test_username, 'password': ''},
                         expected_errors=[('password', 'required')]),
         ]
-        super(LoginFormTestCase, self).test_invalid_data(data_sets=data_sets)
+        super().test_invalid_data(data_sets=data_sets)
 
     def test_invalid_username(self):
         data_sets = [
             FormDataSet({'username': self.test_username[::-1], 'password': self.test_password},
                         expected_errors=[('__all__', 'invalid_login')]),
         ]
-        super(LoginFormTestCase, self).test_invalid_data(data_sets=data_sets)
+        super().test_invalid_data(data_sets=data_sets)
 
     def test_invalid_password(self):
         data_sets = [
             FormDataSet({'username': self.test_username, 'password': self.test_password[::-1]},
                         expected_errors=[('__all__', 'invalid_login')]),
         ]
-        super(LoginFormTestCase, self).test_invalid_data(data_sets=data_sets)
+        super().test_invalid_data(data_sets=data_sets)
 
     def test_inactive_user(self):
         self.user.is_active = False
@@ -68,13 +68,13 @@ class LoginFormTestCase(FormsTestCase):
             FormDataSet({'username': self.test_username, 'password': self.test_password},
                         expected_errors=[('__all__', 'invalid_login')]),
         ]
-        super(LoginFormTestCase, self).test_invalid_data(data_sets=data_sets)
+        super().test_invalid_data(data_sets=data_sets)
 
     def test_valid_credentials(self):
         data_sets = [
             FormDataSet({'username': self.test_username, 'password': self.test_password}),
         ]
-        super(LoginFormTestCase, self).test_valid_data(data_sets=data_sets)
+        super().test_valid_data(data_sets=data_sets)
 
 
 class SetPasswordFormTestCase(FormsTestCase):
@@ -98,56 +98,56 @@ class SetPasswordFormTestCase(FormsTestCase):
             FormDataSet({'new_password': 'mellonAB12+-', 'new_password_repeat': 'mellonAB13+-'},
                         [('new_password_repeat', 'password_mismatch')]),
         ]
-        super(SetPasswordFormTestCase, self).test_invalid_data(data_sets=data_sets, form_kwargs={'user': self.user})
+        super().test_invalid_data(data_sets=data_sets, form_kwargs={'user': self.user})
 
     def test_empty(self):
         data_sets = [
             FormDataSet({'new_password': '', 'new_password_repeat': ''},
                         [('new_password', 'required')]),
         ]
-        super(SetPasswordFormTestCase, self).test_invalid_data(data_sets=data_sets, form_kwargs={'user': self.user})
+        super().test_invalid_data(data_sets=data_sets, form_kwargs={'user': self.user})
 
     def test_too_short(self):
         data_sets = [
             FormDataSet({'new_password': 'mellon', 'new_password_repeat': 'mellon'},
                         [('new_password', 'password_too_short')]),
         ]
-        super(SetPasswordFormTestCase, self).test_invalid_data(data_sets=data_sets, form_kwargs={'user': self.user})
+        super().test_invalid_data(data_sets=data_sets, form_kwargs={'user': self.user})
 
     def test_entirely_numeric(self):
         data_sets = [
             FormDataSet({'new_password': '1357924680', 'new_password_repeat': '1357924680'},
                         [('new_password', 'password_entirely_numeric')]),
         ]
-        super(SetPasswordFormTestCase, self).test_invalid_data(data_sets=data_sets, form_kwargs={'user': self.user})
+        super().test_invalid_data(data_sets=data_sets, form_kwargs={'user': self.user})
 
     def test_too_similar(self):
         data_sets = [
             FormDataSet({'new_password': self.test_username, 'new_password_repeat': self.test_username},
                         [('new_password', 'password_too_similar')]),
         ]
-        super(SetPasswordFormTestCase, self).test_invalid_data(data_sets=data_sets, form_kwargs={'user': self.user})
+        super().test_invalid_data(data_sets=data_sets, form_kwargs={'user': self.user})
 
     def test_too_common(self):
         data_sets = [
             FormDataSet({'new_password': 'password', 'new_password_repeat': 'password'},
                         [('new_password', 'password_too_common')]),
         ]
-        super(SetPasswordFormTestCase, self).test_invalid_data(data_sets=data_sets, form_kwargs={'user': self.user})
+        super().test_invalid_data(data_sets=data_sets, form_kwargs={'user': self.user})
 
     def test_valid(self):
         data_sets = [
             FormDataSet({'new_password': 'mellonAB12+-', 'new_password_repeat': 'mellonAB12+-'}),
             FormDataSet({'new_password': 'mellonAB12+-', 'new_password_repeat': 'mellonAB12+-',
                          'send_password_mail': True}),
-            FormDataSet({'new_password': u'"ä§ MellonAB12+-', 'new_password_repeat': u'"ä§ MellonAB12+-'}),
+            FormDataSet({'new_password': '"ä§ MellonAB12+-', 'new_password_repeat': '"ä§ MellonAB12+-'}),
             FormDataSet({'new_password': 'mellon12' * 128, 'new_password_repeat': 'mellon12' * 128}),
         ]
-        super(SetPasswordFormTestCase, self).test_valid_data(data_sets=data_sets, form_kwargs={'user': self.user})
+        super().test_valid_data(data_sets=data_sets, form_kwargs={'user': self.user})
 
     def test_save(self):
         new_passwords = [
-            u'"ä§ Mellon12'
+            '"ä§ Mellon12'
             'mellon12' * 128,
         ]
 
@@ -162,7 +162,7 @@ class SetPasswordFormTestCase(FormsTestCase):
     @skip('Function is implemented in SetPasswordView instead of SetPasswordForm')
     def test_save_with_mail(self):  # pragma: no cover
         new_passwords = [
-            u'"ä§ Mellon12'
+            '"ä§ Mellon12'
             'mellon12' * 128,
         ]
 
@@ -193,7 +193,7 @@ class CreateAndSendPasswordFormTestCase(FormsTestCase):
 
     def test_labels(self):
         form = self.form_class()
-        self.assertEqual(form.fields['username'].label, ugettext(u'E-Mail-Adresse'))
+        self.assertEqual(form.fields['username'].label, ugettext('E-Mail-Adresse'))
 
     def test_required(self):
         form = self.form_class()

dav_auth/tests/test_screenshots.py

@@ -9,7 +9,7 @@ from selenium.webdriver.common.keys import Keys
 from dav_base.tests.generic import ScreenshotTestCase
 
 TEST_USERNAME = 'root@localhost'
-TEST_PASSWORD = u'me||ön 21ABll'
+TEST_PASSWORD = 'me||ön 21ABll'
 TEST_EMAIL = TEST_USERNAME
 
 
@@ -18,7 +18,7 @@ class TestCase(ScreenshotTestCase):
     screenshot_prefix = 'dav_auth-'
 
     def setUp(self):
-        super(TestCase, self).setUp()
+        super().setUp()
         # Need a test user
         self.test_username = TEST_USERNAME
         self.test_password = TEST_PASSWORD
@@ -105,7 +105,7 @@ class TestCase(ScreenshotTestCase):
 
         # Click on 'set password' -> save set password page
         user_menu = c.find_element_by_css_selector('#login-widget ul')
-        link = user_menu.find_element_by_partial_link_text(ugettext(u'Passwort ändern'))
+        link = user_menu.find_element_by_partial_link_text(ugettext('Passwort ändern'))
         link.click()
         password_field = self.wait_on_presence(c, (By.ID, 'id_new_password'))
         self.save_screenshot('empty_set_password_form', sequence=sequence_name)
@@ -189,7 +189,7 @@ class TestCase(ScreenshotTestCase):
         dropdown_button = self.wait_on_presence(c, (By.ID, 'user_dropdown_button'))
         dropdown_button.click()
         user_menu = c.find_element_by_css_selector('#login-widget ul')
-        link = user_menu.find_element_by_partial_link_text(ugettext(u'Logout'))
+        link = user_menu.find_element_by_partial_link_text(ugettext('Logout'))
         link.click()
         self.wait_until_stale(c, user_menu)
         self.save_screenshot('logout_succeed', sequence=sequence_name)
@@ -200,7 +200,7 @@ class TestCase(ScreenshotTestCase):
         self.wait_on_presence(c, (By.ID, 'id_username'))
 
         # Locate password recreate link, click it -> save password recreate form
-        link = c.find_element_by_partial_link_text(ugettext(u'Passwort vergessen'))
+        link = c.find_element_by_partial_link_text(ugettext('Passwort vergessen'))
         link.click()
         username_field = self.wait_on_presence(c, (By.ID, 'id_username'))
         self.save_screenshot('empty_recreate_password_form', sequence=sequence_name)
@@ -212,7 +212,7 @@ class TestCase(ScreenshotTestCase):
         self.save_screenshot('recreate_password_invalid_user', sequence=sequence_name)
 
         # Locate password recreate link, click it
-        link = c.find_element_by_partial_link_text(ugettext(u'Passwort vergessen'))
+        link = c.find_element_by_partial_link_text(ugettext('Passwort vergessen'))
         link.click()
         username_field = self.wait_on_presence(c, (By.ID, 'id_username'))
 

dav_auth/tests/test_templates.py

@@ -29,7 +29,7 @@ class TemplatesTestCase(SimpleTestCase):
 @tag('browser')
 class TestCase(SeleniumAuthMixin, SeleniumTestCase):
     def setUp(self):
-        super(TestCase, self).setUp()
+        super().setUp()
         # Need a test user
         self.test_username = TEST_USERNAME
         self.test_password = TEST_PASSWORD

dav_auth/tests/test_validators.py

@@ -8,19 +8,19 @@ from ..validators import PasswordScoreValidator, CustomWordlistPasswordValidator
 class PasswordScoreValidatorTestCase(SimpleTestCase):
     def test_too_little_score(self):
         passwords = [
-            u'',  # score = 0
-            u'abcdefghijklmnopq',  # score = 17
-            u'Abcdefghijklmnop',  # score = 16 + 1
-            u'ABcdefghijklmno',  # score = 15 + 2
-            u'AB1defghijklmn',  # score = 14 + 2 + 1
-            u'AB12efghijklm',  # score = 13 + 2 + 2
-            u'AB12+fghijkl',  # score = 12 + 2 + 2 + 1
-            u'AB12+-ghijk',  # score = 11 + 2 + 2 + 2
-            u'AB12+-*hij',  # score = 10 + 2 + 2 + 3
-            u'AB12+-*hi/',  # score = 10 + 2 + 2 + 3
-            u'AB12+-*hi3',  # score = 10 + 2 + 2 + 3
-            u'AB12+-*hiC',  # score = 10 + 2 + 2 + 3
-            u'abcbbbgbbjklmnopqr',  # score = 17
+            '',  # score = 0
+            'abcdefghijklmnopq',  # score = 17
+            'Abcdefghijklmnop',  # score = 16 + 1
+            'ABcdefghijklmno',  # score = 15 + 2
+            'AB1defghijklmn',  # score = 14 + 2 + 1
+            'AB12efghijklm',  # score = 13 + 2 + 2
+            'AB12+fghijkl',  # score = 12 + 2 + 2 + 1
+            'AB12+-ghijk',  # score = 11 + 2 + 2 + 2
+            'AB12+-*hij',  # score = 10 + 2 + 2 + 3
+            'AB12+-*hi/',  # score = 10 + 2 + 2 + 3
+            'AB12+-*hi3',  # score = 10 + 2 + 2 + 3
+            'AB12+-*hiC',  # score = 10 + 2 + 2 + 3
+            'abcbbbgbbjklmnopqr',  # score = 17
         ]
 
         validator = PasswordScoreValidator(min_classes=0)
@@ -31,19 +31,19 @@ class PasswordScoreValidatorTestCase(SimpleTestCase):
             except ValidationError as e:
                 self.assertEqual('too_little_score', e.code)
             else:
-                self.fail(u'%s: no validation error was raised' % password)
+                self.fail('%s: no validation error was raised' % password)
 
     def test_too_few_classes(self):
         passwords = [
-            u'',  # classes = 0
-            u'abcdefgh',  # classes = 1
-            u'abcdef+-',  # classes = 2
-            u'abcd12gh',  # classes = 2
-            u'abcd12-+',  # classes = 3
-            u'abCDefgh',  # classes = 2
-            u'abCDef+-',  # classes = 3
-            u'abCD12gh',  # classes = 3
-            u'ABCD12-+',  # classes = 3
+            '',  # classes = 0
+            'abcdefgh',  # classes = 1
+            'abcdef+-',  # classes = 2
+            'abcd12gh',  # classes = 2
+            'abcd12-+',  # classes = 3
+            'abCDefgh',  # classes = 2
+            'abCDef+-',  # classes = 3
+            'abCD12gh',  # classes = 3
+            'ABCD12-+',  # classes = 3
         ]
 
         validator = PasswordScoreValidator(min_score=0, min_classes=4)
@@ -54,20 +54,20 @@ class PasswordScoreValidatorTestCase(SimpleTestCase):
             except ValidationError as e:
                 self.assertEqual('too_few_classes', e.code)
             else:
-                self.fail(u'%s: no validation error was raised' % password)
+                self.fail('%s: no validation error was raised' % password)
 
     def test_valid(self):
         passwords = [
-            u'Abcdefghijklmnopq',
-            u'ABcdefghijklmnop',
-            u'AB1defghijklmno',
-            u'AB12efghijklmn',
-            u'AB12+fghijklm',
-            u'AB12+-ghijkl',
-            u'AB12+-*hijk',
-            u'ab1defghijklmnopq',
-            u'abcd+fghijklmnopq',
-            u'AB1CDEFGHIJKLMNOPQ',
+            'Abcdefghijklmnopq',
+            'ABcdefghijklmnop',
+            'AB1defghijklmno',
+            'AB12efghijklmn',
+            'AB12+fghijklm',
+            'AB12+-ghijkl',
+            'AB12+-*hijk',
+            'ab1defghijklmnopq',
+            'abcd+fghijklmnopq',
+            'AB1CDEFGHIJKLMNOPQ',
         ]
 
         validator = PasswordScoreValidator()
@@ -82,23 +82,23 @@ class PasswordScoreValidatorTestCase(SimpleTestCase):
 class CustomWordlistPasswordValidatorTestCase(SimpleTestCase):
     def test_invalid(self):
         invalid_passwords = [
-            (u'passwort', [
-                u'Das Passwort darf nicht die Zeichenfolge \'passwort\' enthalten.',
+            ('passwort', [
+                'Das Passwort darf nicht die Zeichenfolge \'passwort\' enthalten.',
             ]),
-            (u'abcdDaVefgh', [
-                u'Das Passwort darf nicht die Zeichenfolge \'dav\' enthalten.',
+            ('abcdDaVefgh', [
+                'Das Passwort darf nicht die Zeichenfolge \'dav\' enthalten.',
             ]),
-            (u'abcdsektIonefgh', [
-                u'Das Passwort darf nicht die Zeichenfolge \'sektion\' enthalten.',
+            ('abcdsektIonefgh', [
+                'Das Passwort darf nicht die Zeichenfolge \'sektion\' enthalten.',
             ]),
-            (u'alpen12verein34KArlsruhE  berge', [
-                u'Das Passwort darf nicht die Zeichenfolge \'karlsruhe\' enthalten.',
-                u'Das Passwort darf nicht die Zeichenfolge \'berge\' enthalten.',
+            ('alpen12verein34KArlsruhE  berge', [
+                'Das Passwort darf nicht die Zeichenfolge \'karlsruhe\' enthalten.',
+                'Das Passwort darf nicht die Zeichenfolge \'berge\' enthalten.',
             ]),
-            (u'heinzel@alpenverein-karlsruhe.de', [
-                u'Das Passwort darf nicht die Zeichenfolge \'heinzel\' enthalten.',
-                u'Das Passwort darf nicht die Zeichenfolge \'alpenverein\' enthalten.',
-                u'Das Passwort darf nicht die Zeichenfolge \'karlsruhe\' enthalten.',
+            ('heinzel@alpenverein-karlsruhe.de', [
+                'Das Passwort darf nicht die Zeichenfolge \'heinzel\' enthalten.',
+                'Das Passwort darf nicht die Zeichenfolge \'alpenverein\' enthalten.',
+                'Das Passwort darf nicht die Zeichenfolge \'karlsruhe\' enthalten.',
             ]),
         ]
 
@@ -114,13 +114,13 @@ class CustomWordlistPasswordValidatorTestCase(SimpleTestCase):
                 for error in errors:
                     self.assertIn(error, expected_errors)
             else:
-                self.fail(u'%s: no validation error was raised' % password)
+                self.fail('%s: no validation error was raised' % password)
 
     def test_valid(self):
         passwords = [
-            u'',
-            u'password',
-            u'münchen',
+            '',
+            'password',
+            'münchen',
         ]
 
         validator = CustomWordlistPasswordValidator()
@@ -134,72 +134,72 @@ class CustomWordlistPasswordValidatorTestCase(SimpleTestCase):
 
 class CharacterClassPasswordValidatorTestCase(SimpleTestCase):
     def setUp(self):
-        super(CharacterClassPasswordValidatorTestCase, self).setUp()
+        super().setUp()
         self.validator = CharacterClassPasswordValidator()
 
     def test_invalid(self):
         invalid_passwords = [
-            (u'', [
-                u'Das Passwort muss mindestens 2 Kleinbuchstaben enthalten.',
-                u'Das Passwort muss mindestens 2 Großbuchstaben enthalten.',
-                u'Das Passwort muss mindestens 2 Ziffern enthalten.',
-                u'Das Passwort muss mindestens 2 Sonderzeichen enthalten.',
+            ('', [
+                'Das Passwort muss mindestens 2 Kleinbuchstaben enthalten.',
+                'Das Passwort muss mindestens 2 Großbuchstaben enthalten.',
+                'Das Passwort muss mindestens 2 Ziffern enthalten.',
+                'Das Passwort muss mindestens 2 Sonderzeichen enthalten.',
             ]),
-            (u'A+-', [
-                u'Das Passwort muss mindestens 2 Kleinbuchstaben enthalten.',
-                u'Das Passwort muss mindestens 2 Großbuchstaben enthalten.',
-                u'Das Passwort muss mindestens 2 Ziffern enthalten.',
+            ('A+-', [
+                'Das Passwort muss mindestens 2 Kleinbuchstaben enthalten.',
+                'Das Passwort muss mindestens 2 Großbuchstaben enthalten.',
+                'Das Passwort muss mindestens 2 Ziffern enthalten.',
             ]),
-            (u'1234567890*', [
-                u'Das Passwort muss mindestens 2 Kleinbuchstaben enthalten.',
-                u'Das Passwort muss mindestens 2 Großbuchstaben enthalten.',
-                u'Das Passwort muss mindestens 2 Sonderzeichen enthalten.',
+            ('1234567890*', [
+                'Das Passwort muss mindestens 2 Kleinbuchstaben enthalten.',
+                'Das Passwort muss mindestens 2 Großbuchstaben enthalten.',
+                'Das Passwort muss mindestens 2 Sonderzeichen enthalten.',
             ]),
-            (u'34*/()', [
-                u'Das Passwort muss mindestens 2 Kleinbuchstaben enthalten.',
-                u'Das Passwort muss mindestens 2 Großbuchstaben enthalten.',
+            ('34*/()', [
+                'Das Passwort muss mindestens 2 Kleinbuchstaben enthalten.',
+                'Das Passwort muss mindestens 2 Großbuchstaben enthalten.',
             ]),
-            (u'AA', [
-                u'Das Passwort muss mindestens 2 Kleinbuchstaben enthalten.',
-                u'Das Passwort muss mindestens 2 Ziffern enthalten.',
-                u'Das Passwort muss mindestens 2 Sonderzeichen enthalten.',
+            ('AA', [
+                'Das Passwort muss mindestens 2 Kleinbuchstaben enthalten.',
+                'Das Passwort muss mindestens 2 Ziffern enthalten.',
+                'Das Passwort muss mindestens 2 Sonderzeichen enthalten.',
             ]),
-            (u'CD0.,', [
-                u'Das Passwort muss mindestens 2 Kleinbuchstaben enthalten.',
-                u'Das Passwort muss mindestens 2 Ziffern enthalten.',
+            ('CD0.,', [
+                'Das Passwort muss mindestens 2 Kleinbuchstaben enthalten.',
+                'Das Passwort muss mindestens 2 Ziffern enthalten.',
             ]),
-            (u'EF56', [
-                u'Das Passwort muss mindestens 2 Kleinbuchstaben enthalten.',
-                u'Das Passwort muss mindestens 2 Sonderzeichen enthalten.',
+            ('EF56', [
+                'Das Passwort muss mindestens 2 Kleinbuchstaben enthalten.',
+                'Das Passwort muss mindestens 2 Sonderzeichen enthalten.',
             ]),
-            (u'8GH?!8', [
-                u'Das Passwort muss mindestens 2 Kleinbuchstaben enthalten.',
+            ('8GH?!8', [
+                'Das Passwort muss mindestens 2 Kleinbuchstaben enthalten.',
             ]),
-            (u'bbX', [
-                u'Das Passwort muss mindestens 2 Großbuchstaben enthalten.',
-                u'Das Passwort muss mindestens 2 Ziffern enthalten.',
-                u'Das Passwort muss mindestens 2 Sonderzeichen enthalten.',
+            ('bbX', [
+                'Das Passwort muss mindestens 2 Großbuchstaben enthalten.',
+                'Das Passwort muss mindestens 2 Ziffern enthalten.',
+                'Das Passwort muss mindestens 2 Sonderzeichen enthalten.',
             ]),
-            (u'$cd%', [
-                u'Das Passwort muss mindestens 2 Großbuchstaben enthalten.',
-                u'Das Passwort muss mindestens 2 Ziffern enthalten.',
+            ('$cd%', [
+                'Das Passwort muss mindestens 2 Großbuchstaben enthalten.',
+                'Das Passwort muss mindestens 2 Ziffern enthalten.',
             ]),
-            (u'ef90', [
-                u'Das Passwort muss mindestens 2 Großbuchstaben enthalten.',
-                u'Das Passwort muss mindestens 2 Sonderzeichen enthalten.',
+            ('ef90', [
+                'Das Passwort muss mindestens 2 Großbuchstaben enthalten.',
+                'Das Passwort muss mindestens 2 Sonderzeichen enthalten.',
             ]),
-            (u'1g=h3~', [
-                u'Das Passwort muss mindestens 2 Großbuchstaben enthalten.',
+            ('1g=h3~', [
+                'Das Passwort muss mindestens 2 Großbuchstaben enthalten.',
             ]),
-            (u'Gi&jH', [
-                u'Das Passwort muss mindestens 2 Ziffern enthalten.',
-                u'Das Passwort muss mindestens 2 Sonderzeichen enthalten.',
+            ('Gi&jH', [
+                'Das Passwort muss mindestens 2 Ziffern enthalten.',
+                'Das Passwort muss mindestens 2 Sonderzeichen enthalten.',
             ]),
-            (u'IkK:i;', [
-                u'Das Passwort muss mindestens 2 Ziffern enthalten.',
+            ('IkK:i;', [
+                'Das Passwort muss mindestens 2 Ziffern enthalten.',
             ]),
-            (u'mKn4L8', [
-                u'Das Passwort muss mindestens 2 Sonderzeichen enthalten.',
+            ('mKn4L8', [
+                'Das Passwort muss mindestens 2 Sonderzeichen enthalten.',
             ]),
         ]
 
@@ -215,10 +215,10 @@ class CharacterClassPasswordValidatorTestCase(SimpleTestCase):
                 for error in errors:
                     self.assertIn(error, expected_errors)
             else:
-                self.fail(u'%s: no validation error was raised' % password)
+                self.fail('%s: no validation error was raised' % password)
 
     def test_valid(self):
-        valid_passwords = [u'abCD12+-']
+        valid_passwords = ['abCD12+-']
         validator = self.validator
         for password in valid_passwords:
             try:

dav_auth/tests/test_views.py

@@ -10,7 +10,7 @@ from django.urls import reverse
 from ..forms import LoginForm, SetPasswordForm, CreateAndSendPasswordForm
 
 TEST_USERNAME = 'root@localhost'
-TEST_PASSWORD = u'me||ön 21ABll'
+TEST_PASSWORD = 'me||ön 21ABll'
 TEST_EMAIL = TEST_USERNAME
 
 
@@ -30,12 +30,12 @@ class ViewsTestCase(TestCase):
         cls.recreate_password_url = reverse('dav_auth:recreate_password')
 
         # Some messages
-        cls.wrong_credentials_message = ugettext(u'Benutzername oder Passwort falsch.')
-        cls.logout_message = ugettext(u'Benutzer abgemeldet.')
-        cls.set_password_message = ugettext(u'Passwort gespeichert.')
+        cls.wrong_credentials_message = ugettext('Benutzername oder Passwort falsch.')
+        cls.logout_message = ugettext('Benutzer abgemeldet.')
+        cls.set_password_message = ugettext('Passwort gespeichert.')
 
     def setUp(self):
-        super(ViewsTestCase, self).setUp()
+        super().setUp()
         # Need a test user
         self.test_username = TEST_USERNAME
         self.test_password = TEST_PASSWORD
@@ -74,7 +74,7 @@ class ViewsTestCase(TestCase):
 
     def test_integrated_login_succeed(self):
         username = self.user.username
-        message = ugettext(u'Benutzer angemeldet: %(username)s') % {'username': username}
+        message = ugettext('Benutzer angemeldet: %(username)s') % {'username': username}
 
         response = self.client.post(self.login_url, {'username': username, 'password': self.test_password})
         self.assertEqual(response.status_code, 302)
@@ -166,7 +166,7 @@ class ViewsTestCase(TestCase):
                                                'send_password_mail': True})
         self.assertEqual(len(django_mail.outbox), 1)
         mail = django_mail.outbox[0]
-        recipient = u'"%s" <%s>' % (self.user.get_full_name(), self.user.email)
+        recipient = '"%s" <%s>' % (self.user.get_full_name(), self.user.email)
         recipients = mail.recipients()
         self.assertIn(recipient, recipients)
         self.assertEqual(len(recipients), 1)
@@ -202,7 +202,7 @@ class ViewsTestCase(TestCase):
 
         self.assertEqual(len(django_mail.outbox), 1)
         mail = django_mail.outbox[0]
-        recipient = u'"%s" <%s>' % (self.user.get_full_name(), self.user.email)
+        recipient = '"%s" <%s>' % (self.user.get_full_name(), self.user.email)
         recipients = mail.recipients()
         self.assertIn(recipient, recipients)
         self.assertEqual(len(recipients), 1)

dav_auth/validators.py

@@ -56,67 +56,67 @@ class PasswordScoreValidator:
         score, used_classes = self._get_score(password, user=user)
 
         if used_classes < self.min_classes:
-            raise ValidationError(_(u'Das Passwort muss Zeichen aus mindestens %(min_classes)d'
-                                    u' verschiedenen Arten von Zeichen bestehen'
-                                    u' (d.h. Kleinbuchstaben, Großbuchstaben, Ziffern und Sonderzeichen).'),
+            raise ValidationError(_('Das Passwort muss Zeichen aus mindestens %(min_classes)d'
+                                    ' verschiedenen Arten von Zeichen bestehen'
+                                    ' (d.h. Kleinbuchstaben, Großbuchstaben, Ziffern und Sonderzeichen).'),
                                   code='too_few_classes',
                                   params={'min_classes': self.min_classes})
 
         if score < self.min_score:
-            raise ValidationError(_(u'Dieses Passwort ist zu einfach. Benutze mehr Zeichen'
-                                    u' und gegebenenfalls auch Großbuchstaben, Ziffern und Sonderzeichen.'),
+            raise ValidationError(_('Dieses Passwort ist zu einfach. Benutze mehr Zeichen'
+                                    ' und gegebenenfalls auch Großbuchstaben, Ziffern und Sonderzeichen.'),
                                   code='too_little_score')
 
         return score
 
     def get_help_text(self):
-        text = u'%s\n%s' % (
-            _(u'The password must get a minimum score of %d points.') % self.min_score,
-            _(u'For each character the score is increased by 1 point.'),
+        text = '%s\n%s' % (
+            _('The password must get a minimum score of %d points.') % self.min_score,
+            _('For each character the score is increased by 1 point.'),
         )
         if self.lcredit > 0:
             text += '\n'
-            text += _(u'The first %d lower characters increase the score by 1 point each.') % self.lcredit
+            text += _('The first %d lower characters increase the score by 1 point each.') % self.lcredit
         if self.ucredit > 0:
             text += '\n'
-            text += _(u'The first %d upper characters increase the score by 1 point each.') % self.ucredit
+            text += _('The first %d upper characters increase the score by 1 point each.') % self.ucredit
         if self.dcredit > 0:
             text += '\n'
-            text += _(u'The first %d digits increase the score by 1 point each.') % self.dcredit
+            text += _('The first %d digits increase the score by 1 point each.') % self.dcredit
         if self.ocredit > 0:
             text += '\n'
-            text += _(u'The first %d non alpha numeric characters'
-                      u' increase the score by 1 point each.') % self.ocredit
+            text += _('The first %d non alpha numeric characters'
+                      ' increase the score by 1 point each.') % self.ocredit
         if self.max_repeat > 0:
             text += '\n'
-            text += _(u'If a particular character is used more than %d times,'
-                      u' it will not increase the score anymore.') % self.max_repeat
+            text += _('If a particular character is used more than %d times,'
+                      ' it will not increase the score anymore.') % self.max_repeat
         if self.min_classes > 0:
             text += '\n'
-            text += _(u'Also the password must contain characters from %d different character classes'
-                      u' (i.e. lower, upper, digits, others).') % self.min_classes
+            text += _('Also the password must contain characters from %d different character classes'
+                      ' (i.e. lower, upper, digits, others).') % self.min_classes
         return text
 
 
 class CustomWordlistPasswordValidator:
     context = 'the Sektion Karlsruhe'
     words = (
-        u'dav',
-        u'berge',
-        u'sektion',
-        u'karlsruhe',
-        u'alpenverein',
-        u'heinzel',
-        u'passwort',
+        'dav',
+        'berge',
+        'sektion',
+        'karlsruhe',
+        'alpenverein',
+        'heinzel',
+        'passwort',
     )
 
-    def validate(self, password, user=None):
+    def validate(self, password, user=None):  # pylint: disable=unused-argument
         errors = []
 
         lower_pw = password.lower()
         for word in self.words:
             if word in lower_pw:
-                error = ValidationError(_(u'Das Passwort darf nicht die Zeichenfolge \'%(word)s\' enthalten.'),
+                error = ValidationError(_('Das Passwort darf nicht die Zeichenfolge \'%(word)s\' enthalten.'),
                                         code='forbidden_word',
                                         params={'word': word})
                 errors.append(error)
@@ -125,10 +125,10 @@ class CustomWordlistPasswordValidator:
             raise ValidationError(errors)
 
     def get_help_text(self):
-        text = _(u'The password must not contain some specific words,'
-                 u' that are common in context with %(context)s.') % {'context': self.context}
-        text += u'\n'
-        text += _(u'All words are matched case insensitive.')
+        text = _('The password must not contain some specific words,'
+                 ' that are common in context with %(context)s.') % {'context': self.context}
+        text += '\n'
+        text += _('All words are matched case insensitive.')
         return text
 
 
@@ -163,26 +163,26 @@ class CharacterClassPasswordValidator:
         self.minimum_digits = minimum_digits
         self.minimum_others = minimum_others
 
-    def validate(self, password, user=None):
+    def validate(self, password, user=None):  # pylint: disable=unused-argument
         errors = []
         if not self._is_enough_lower(password):
-            error = ValidationError(_(u'Das Passwort muss mindestens %(min_lower)d Kleinbuchstaben enthalten.'),
+            error = ValidationError(_('Das Passwort muss mindestens %(min_lower)d Kleinbuchstaben enthalten.'),
                                     code='too_few_lower_characters',
                                     params={'min_lower': self.minimum_lower})
             errors.append(error)
         if not self._is_enough_upper(password):
-            error = ValidationError(_(u'Das Passwort muss mindestens %(min_upper)d Großbuchstaben enthalten.'),
+            error = ValidationError(_('Das Passwort muss mindestens %(min_upper)d Großbuchstaben enthalten.'),
                                     code='too_few_upper_characters',
                                     params={'min_upper': self.minimum_upper})
             errors.append(error)
         if not self._is_enough_digits(password):
-            error = ValidationError(_(u'Das Passwort muss mindestens %(min_digits)d Ziffern enthalten.'),
+            error = ValidationError(_('Das Passwort muss mindestens %(min_digits)d Ziffern enthalten.'),
                                     code='too_few_digits',
                                     params={'min_digits': self.minimum_digits})
             errors.append(error)
         if not self._is_enough_others(password):
-            error = ValidationError(_(u'Das Passwort muss mindestens %(min_others)d'
-                                      u' Sonderzeichen enthalten.'),
+            error = ValidationError(_('Das Passwort muss mindestens %(min_others)d'
+                                      ' Sonderzeichen enthalten.'),
                                     code='too_few_other_characters',
                                     params={'min_others': self.minimum_others})
             errors.append(error)
@@ -191,7 +191,7 @@ class CharacterClassPasswordValidator:
             raise ValidationError(errors)
 
     def get_help_text(self):
-        text = u'%s %s %s %s' % (
+        text = '%s %s %s %s' % (
             _('The password must contain at least %d characters from a-z.') % self.minimum_lower,
             _('The password must contain at least %d characters from A-Z.') % self.minimum_upper,
             _('The password must contain at least %d digits from 0-9.') % self.minimum_digits,

dav_auth/views.py

@@ -24,39 +24,39 @@ class LoginView(auth_views.LoginView):
     template_name = 'dav_auth/forms/login.html'
 
     def get_redirect_url(self):
-        url = super(LoginView, self).get_redirect_url()
+        url = super().get_redirect_url()
         if not url and app_config.settings.login_redirect_url:
             url = resolve_url(app_config.settings.login_redirect_url)
         return url
 
     def form_valid(self, form):
-        r = super(LoginView, self).form_valid(form)
-        messages.success(self.request, _(u'Benutzer angemeldet: %(username)s') % {'username': form.get_user()})
+        r = super().form_valid(form)
+        messages.success(self.request, _('Benutzer angemeldet: %(username)s') % {'username': form.get_user()})
         try:
             validate_password(form.cleaned_data['password'])
         except ValidationError as e:
-            logger.warning(u'Weak password (%d): %s', self.request.user.pk, e)
-            message = u'<br />\n<p>\n'
-            message += u'Dein Passwort entspricht nicht mehr den aktuellen Passwortrichtlinien.<br />\n'
-            message += u'Bitte hilf uns die Daten deiner Teilnehmer zu schützen und ändere dein Passwort.<br />\n'
-            message += u'</p>\n'
-            message += u'<p>\n'
-            message += u'<a href="%(href)s">Passwort ändern</a>\n' % {'href': reverse('dav_auth:set_password')}
-            message += u'</p>\n<br />\n'
+            logger.warning('Weak password (%d): %s', self.request.user.pk, e)
+            message = '<br />\n<p>\n'
+            message += 'Dein Passwort entspricht nicht mehr den aktuellen Passwortrichtlinien.<br />\n'
+            message += 'Bitte hilf uns die Daten deiner Teilnehmer zu schützen und ändere dein Passwort.<br />\n'
+            message += '</p>\n'
+            message += '<p>\n'
+            message += '<a href="%(href)s">Passwort ändern</a>\n' % {'href': reverse('dav_auth:set_password')}
+            message += '</p>\n<br />\n'
             messages.warning(self.request, mark_safe(message))
         return r
 
 
 class LogoutView(auth_views.LogoutView):
     def get_next_page(self):
-        url = super(LogoutView, self).get_next_page()
+        url = super().get_next_page()
         if not url and app_config.settings.logout_redirect_url:
             url = resolve_url(app_config.settings.logout_redirect_url)
         return url
 
     def dispatch(self, request, *args, **kwargs):
-        r = super(LogoutView, self).dispatch(request, *args, **kwargs)
-        messages.success(self.request, _(u'Benutzer abgemeldet.'))
+        r = super().dispatch(request, *args, **kwargs)
+        messages.success(self.request, _('Benutzer abgemeldet.'))
         return r
 
 
@@ -68,8 +68,8 @@ class SetPasswordView(auth_views.PasswordChangeView):
         return resolve_url(app_config.settings.login_redirect_url)
 
     def form_valid(self, form):
-        r = super(SetPasswordView, self).form_valid(form)
-        messages.success(self.request, _(u'Passwort gespeichert.'))
+        r = super().form_valid(form)
+        messages.success(self.request, _('Passwort gespeichert.'))
         if form.cleaned_data.get('send_password_mail', False):
             email = emails.PasswordSetEmail(self.request.user, form.cleaned_data['new_password'])
             email.send()
@@ -91,14 +91,14 @@ class CreateAndSendPasswordView(generic.FormView):
             user.save()
             email = emails.PasswordSetEmail(user, random_password)
             email.send()
-            messages.success(self.request, _(u'Neues Passwort versendet.'))
+            messages.success(self.request, _('Neues Passwort versendet.'))
             logger.info('Password recreated for user \'%s\'', username)
         except user_model.DoesNotExist:
             logger.warning('Password recreated for unknown user \'%s\'', username)
 
-        return super(CreateAndSendPasswordView, self).form_valid(form)
+        return super().form_valid(form)
 
     def get(self, request, *args, **kwargs):
         if request.user.is_authenticated:
             return HttpResponseRedirect(reverse('dav_auth:set_password'))
-        return super(CreateAndSendPasswordView, self).get(request, *args, **kwargs)
+        return super().get(request, *args, **kwargs)