Ticket #28858: no-else-after-return.patch

django/apps/config.py

@@ -71 +71 @@
                 "The app module %r has multiple filesystem locations (%r); "
                 "you must configure this app with an AppConfig subclass "
                 "with a 'path' class attribute." % (module, paths))
-        elif not paths:
+        if not paths:
             raise ImproperlyConfigured(
                 "The app module %r has no filesystem location, "
                 "you must configure this app with an AppConfig subclass "

django/conf/urls/static.py

@@ -19 +19 @@
     """
     if not prefix:
         raise ImproperlyConfigured("Empty static prefix not permitted")
-    elif not settings.DEBUG or '://' in prefix:
+    if not settings.DEBUG or '://' in prefix:
         # No-op if not in debug mode or a non-local prefix.
         return []
     return [

django/contrib/admin/checks.py

@@ -87 +87 @@
         """
         if not isinstance(obj.autocomplete_fields, (list, tuple)):
             return must_be('a list or tuple', option='autocomplete_fields', obj=obj, id='admin.E036')
-        else:
-            return list(chain.from_iterable([
-                self._check_autocomplete_fields_item(obj, obj.model, field_name, 'autocomplete_fields[%d]' % index)
-                for index, field_name in enumerate(obj.autocomplete_fields)
-            ]))
+        return list(chain.from_iterable([
+            self._check_autocomplete_fields_item(obj, obj.model, field_name, 'autocomplete_fields[%d]' % index)
+            for index, field_name in enumerate(obj.autocomplete_fields)
+        ]))
 
     def _check_autocomplete_fields_item(self, obj, model, field_name, label):
         """
@@ -122 +121 @@
                         id='admin.E039',
                     )
                 ]
-            elif not related_admin.search_fields:
+            if not related_admin.search_fields:
                 return [
                     checks.Error(
                         '%s must define "search_fields", because it\'s '
@@ -142 +141 @@
 
         if not isinstance(obj.raw_id_fields, (list, tuple)):
             return must_be('a list or tuple', option='raw_id_fields', obj=obj, id='admin.E001')
-        else:
-            return list(chain.from_iterable(
-                self._check_raw_id_fields_item(obj, obj.model, field_name, 'raw_id_fields[%d]' % index)
-                for index, field_name in enumerate(obj.raw_id_fields)
-            ))
+        return list(chain.from_iterable(
+            self._check_raw_id_fields_item(obj, obj.model, field_name, 'raw_id_fields[%d]' % index)
+            for index, field_name in enumerate(obj.raw_id_fields)
+        ))
 
     def _check_raw_id_fields_item(self, obj, model, field_name, label):
         """ Check an item of `raw_id_fields`, i.e. check that field named
@@ -162 +160 @@
             if not field.many_to_many and not isinstance(field, models.ForeignKey):
                 return must_be('a foreign key or a many-to-many field',
                                option=label, obj=obj, id='admin.E003')
-            else:
-                return []
+            return []
 
     def _check_fields(self, obj):
         """ Check that `fields` only refer to existing fields, doesn't contain
@@ -172 +169 @@
 
         if obj.fields is None:
             return []
-        elif not isinstance(obj.fields, (list, tuple)):
+        if not isinstance(obj.fields, (list, tuple)):
             return must_be('a list or tuple', option='fields', obj=obj, id='admin.E004')
-        elif obj.fieldsets:
+        if obj.fieldsets:
             return [
                 checks.Error(
                     "Both 'fieldsets' and 'fields' are specified.",
@@ -203 +200 @@
 
         if obj.fieldsets is None:
             return []
-        elif not isinstance(obj.fieldsets, (list, tuple)):
+        if not isinstance(obj.fieldsets, (list, tuple)):
             return must_be('a list or tuple', option='fieldsets', obj=obj, id='admin.E007')
-        else:
-            return list(chain.from_iterable(
-                self._check_fieldsets_item(obj, obj.model, fieldset, 'fieldsets[%d]' % index)
-                for index, fieldset in enumerate(obj.fieldsets)
-            ))
+        return list(chain.from_iterable(
+            self._check_fieldsets_item(obj, obj.model, fieldset, 'fieldsets[%d]' % index)
+            for index, fieldset in enumerate(obj.fieldsets)
+        ))
 
     def _check_fieldsets_item(self, obj, model, fieldset, label):
         """ Check an item of `fieldsets`, i.e. check that this is a pair of a
@@ -217 +213 @@
 
         if not isinstance(fieldset, (list, tuple)):
             return must_be('a list or tuple', option=label, obj=obj, id='admin.E008')
-        elif len(fieldset) != 2:
+        if len(fieldset) != 2:
             return must_be('of length 2', option=label, obj=obj, id='admin.E009')
-        elif not isinstance(fieldset[1], dict):
+        if not isinstance(fieldset[1], dict):
             return must_be('a dictionary', option='%s[1]' % label, obj=obj, id='admin.E010')
-        elif 'fields' not in fieldset[1]:
+        if 'fields' not in fieldset[1]:
             return [
                 checks.Error(
                     "The value of '%s[1]' must contain the key 'fields'." % label,
@@ -229 +225 @@
                     id='admin.E011',
                 )
             ]
-        elif not isinstance(fieldset[1]['fields'], (list, tuple)):
+        if not isinstance(fieldset[1]['fields'], (list, tuple)):
             return must_be('a list or tuple', option="%s[1]['fields']" % label, obj=obj, id='admin.E008')
 
         fields = flatten(fieldset[1]['fields'])
@@ -256 +252 @@
                 self._check_field_spec_item(obj, model, field_name, "%s[%d]" % (label, index))
                 for index, field_name in enumerate(fields)
             ))
-        else:
-            return self._check_field_spec_item(obj, model, fields, label)
+        return self._check_field_spec_item(obj, model, fields, label)
 
     def _check_field_spec_item(self, obj, model, field_name, label):
         if field_name in obj.readonly_fields:
@@ -265 +260 @@
             # it's in readonly_fields, readonly_fields will handle the
             # validation of such things.
             return []
+        try:
+            field = model._meta.get_field(field_name)
+        except FieldDoesNotExist:
+            # If we can't find a field on the model that matches, it could
+            # be an extra field on the form.
+            return []
         else:
-            try:
-                field = model._meta.get_field(field_name)
-            except FieldDoesNotExist:
-                # If we can't find a field on the model that matches, it could
-                # be an extra field on the form.
-                return []
-            else:
-                if (isinstance(field, models.ManyToManyField) and
-                        not field.remote_field.through._meta.auto_created):
-                    return [
-                        checks.Error(
-                            "The value of '%s' cannot include the ManyToManyField '%s', "
-                            "because that field manually specifies a relationship model."
-                            % (label, field_name),
-                            obj=obj.__class__,
-                            id='admin.E013',
-                        )
-                    ]
-                else:
-                    return []
+            if (isinstance(field, models.ManyToManyField) and
+                    not field.remote_field.through._meta.auto_created):
+                return [
+                    checks.Error(
+                        "The value of '%s' cannot include the ManyToManyField '%s', "
+                        "because that field manually specifies a relationship model."
+                        % (label, field_name),
+                        obj=obj.__class__,
+                        id='admin.E013',
+                    )
+                ]
+            return []
 
     def _check_exclude(self, obj):
         """ Check that exclude is a sequence without duplicates. """
 
         if obj.exclude is None:  # default value is None
             return []
-        elif not isinstance(obj.exclude, (list, tuple)):
+        if not isinstance(obj.exclude, (list, tuple)):
             return must_be('a list or tuple', option='exclude', obj=obj, id='admin.E014')
-        elif len(obj.exclude) > len(set(obj.exclude)):
+        if len(obj.exclude) > len(set(obj.exclude)):
             return [
                 checks.Error(
                     "The value of 'exclude' contains duplicate field(s).",
@@ -302 +295 @@
                     id='admin.E015',
                 )
             ]
-        else:
-            return []
+        return []
 
     def _check_form(self, obj):
         """ Check that form subclasses BaseModelForm. """
         if not issubclass(obj.form, BaseModelForm):
             return must_inherit_from(parent='BaseModelForm', option='form',
                                      obj=obj, id='admin.E016')
-        else:
-            return []
+        return []
 
     def _check_filter_vertical(self, obj):
         """ Check that filter_vertical is a sequence of field names. """
         if not isinstance(obj.filter_vertical, (list, tuple)):
             return must_be('a list or tuple', option='filter_vertical', obj=obj, id='admin.E017')
-        else:
-            return list(chain.from_iterable(
-                self._check_filter_item(obj, obj.model, field_name, "filter_vertical[%d]" % index)
-                for index, field_name in enumerate(obj.filter_vertical)
-            ))
+        return list(chain.from_iterable(
+            self._check_filter_item(obj, obj.model, field_name, "filter_vertical[%d]" % index)
+            for index, field_name in enumerate(obj.filter_vertical)
+        ))
 
     def _check_filter_horizontal(self, obj):
         """ Check that filter_horizontal is a sequence of field names. """
         if not isinstance(obj.filter_horizontal, (list, tuple)):
             return must_be('a list or tuple', option='filter_horizontal', obj=obj, id='admin.E018')
-        else:
-            return list(chain.from_iterable(
-                self._check_filter_item(obj, obj.model, field_name, "filter_horizontal[%d]" % index)
-                for index, field_name in enumerate(obj.filter_horizontal)
-            ))
+        return list(chain.from_iterable(
+            self._check_filter_item(obj, obj.model, field_name, "filter_horizontal[%d]" % index)
+            for index, field_name in enumerate(obj.filter_horizontal)
+        ))
 
     def _check_filter_item(self, obj, model, field_name, label):
         """ Check one item of `filter_vertical` or `filter_horizontal`, i.e.
@@ -342 +331 @@
         except FieldDoesNotExist:
             return refer_to_missing_field(field=field_name, option=label,
                                           model=model, obj=obj, id='admin.E019')
-        else:
-            if not field.many_to_many:
-                return must_be('a many-to-many field', option=label, obj=obj, id='admin.E020')
-            else:
-                return []
+        if not field.many_to_many:
+            return must_be('a many-to-many field', option=label, obj=obj, id='admin.E020')
+        return []
 
     def _check_radio_fields(self, obj):
         """ Check that `radio_fields` is a dictionary. """
         if not isinstance(obj.radio_fields, dict):
             return must_be('a dictionary', option='radio_fields', obj=obj, id='admin.E021')
-        else:
-            return list(chain.from_iterable(
-                self._check_radio_fields_key(obj, obj.model, field_name, 'radio_fields') +
-                self._check_radio_fields_value(obj, val, 'radio_fields["%s"]' % field_name)
-                for field_name, val in obj.radio_fields.items()
-            ))
+        return list(chain.from_iterable(
+            self._check_radio_fields_key(obj, obj.model, field_name, 'radio_fields') +
+            self._check_radio_fields_value(obj, val, 'radio_fields["%s"]' % field_name)
+            for field_name, val in obj.radio_fields.items()
+        ))
 
     def _check_radio_fields_key(self, obj, model, field_name, label):
         """ Check that a key of `radio_fields` dictionary is name of existing
@@ -380 +366 @@
                         id='admin.E023',
                     )
                 ]
-            else:
-                return []
+            return []
 
     def _check_radio_fields_value(self, obj, val, label):
         """ Check type of a value of `radio_fields` dictionary. """
@@ -396 +381 @@
                     id='admin.E024',
                 )
             ]
-        else:
-            return []
+        return []
 
     def _check_view_on_site_url(self, obj):
         if not callable(obj.view_on_site) and not isinstance(obj.view_on_site, bool):
@@ -408 +392 @@
                     id='admin.E025',
                 )
             ]
-        else:
-            return []
+        return []
 
     def _check_prepopulated_fields(self, obj):
         """ Check that `prepopulated_fields` is a dictionary containing allowed
         field types. """
         if not isinstance(obj.prepopulated_fields, dict):
             return must_be('a dictionary', option='prepopulated_fields', obj=obj, id='admin.E026')
-        else:
-            return list(chain.from_iterable(
-                self._check_prepopulated_fields_key(obj, obj.model, field_name, 'prepopulated_fields') +
-                self._check_prepopulated_fields_value(obj, obj.model, val, 'prepopulated_fields["%s"]' % field_name)
-                for field_name, val in obj.prepopulated_fields.items()
-            ))
+        return list(chain.from_iterable(
+            self._check_prepopulated_fields_key(obj, obj.model, field_name, 'prepopulated_fields') +
+            self._check_prepopulated_fields_value(obj, obj.model, val, 'prepopulated_fields["%s"]' % field_name)
+            for field_name, val in obj.prepopulated_fields.items()
+        ))
 
     def _check_prepopulated_fields_key(self, obj, model, field_name, label):
         """ Check a key of `prepopulated_fields` dictionary, i.e. check that it
@@ -443 +425 @@
                         id='admin.E028',
                     )
                 ]
-            else:
-                return []
+            return []
 
     def _check_prepopulated_fields_value(self, obj, model, val, label):
         """ Check a value of `prepopulated_fields` dictionary, i.e. it's an
@@ -452 +433 @@
 
         if not isinstance(val, (list, tuple)):
             return must_be('a list or tuple', option=label, obj=obj, id='admin.E029')
-        else:
-            return list(chain.from_iterable(
-                self._check_prepopulated_fields_value_item(obj, model, subfield_name, "%s[%r]" % (label, index))
-                for index, subfield_name in enumerate(val)
-            ))
+        return list(chain.from_iterable(
+            self._check_prepopulated_fields_value_item(obj, model, subfield_name, "%s[%r]" % (label, index))
+            for index, subfield_name in enumerate(val)
+        ))
 
     def _check_prepopulated_fields_value_item(self, obj, model, field_name, label):
         """ For `prepopulated_fields` equal to {"slug": ("title",)},
@@ -475 +455 @@
         # ordering = None
         if obj.ordering is None:  # The default value is None
             return []
-        elif not isinstance(obj.ordering, (list, tuple)):
+        if not isinstance(obj.ordering, (list, tuple)):
             return must_be('a list or tuple', option='ordering', obj=obj, id='admin.E031')
-        else:
-            return list(chain.from_iterable(
-                self._check_ordering_item(obj, obj.model, field_name, 'ordering[%d]' % index)
-                for index, field_name in enumerate(obj.ordering)
-            ))
+        return list(chain.from_iterable(
+            self._check_ordering_item(obj, obj.model, field_name, 'ordering[%d]' % index)
+            for index, field_name in enumerate(obj.ordering)
+        ))
 
     def _check_ordering_item(self, obj, model, field_name, label):
         """ Check that `ordering` refers to existing fields. """
@@ -496 +475 @@
                     id='admin.E032',
                 )
             ]
-        elif field_name == '?':
+        if field_name == '?':
             return []
-        elif LOOKUP_SEP in field_name:
+        if LOOKUP_SEP in field_name:
             # Skip ordering in the format field1__field2 (FIXME: checking
             # this format would be nice, but it's a little fiddly).
             return []
+        if field_name.startswith('-'):
+            field_name = field_name[1:]
+        if field_name == 'pk':
+            return []
+        try:
+            model._meta.get_field(field_name)
+        except FieldDoesNotExist:
+            return refer_to_missing_field(field=field_name, option=label, model=model, obj=obj, id='admin.E033')
         else:
-            if field_name.startswith('-'):
-                field_name = field_name[1:]
-            if field_name == 'pk':
-                return []
-            try:
-                model._meta.get_field(field_name)
-            except FieldDoesNotExist:
-                return refer_to_missing_field(field=field_name, option=label, model=model, obj=obj, id='admin.E033')
-            else:
-                return []
+            return []
 
     def _check_readonly_fields(self, obj):
         """ Check that readonly_fields refers to proper attribute or field. """
 
         if obj.readonly_fields == ():
             return []
-        elif not isinstance(obj.readonly_fields, (list, tuple)):
+        if not isinstance(obj.readonly_fields, (list, tuple)):
             return must_be('a list or tuple', option='readonly_fields', obj=obj, id='admin.E034')
-        else:
-            return list(chain.from_iterable(
-                self._check_readonly_fields_item(obj, obj.model, field_name, "readonly_fields[%d]" % index)
-                for index, field_name in enumerate(obj.readonly_fields)
-            ))
+        return list(chain.from_iterable(
+            self._check_readonly_fields_item(obj, obj.model, field_name, "readonly_fields[%d]" % index)
+            for index, field_name in enumerate(obj.readonly_fields)
+        ))
 
     def _check_readonly_fields_item(self, obj, model, field_name, label):
         if callable(field_name):
             return []
-        elif hasattr(obj, field_name):
+        if hasattr(obj, field_name):
             return []
-        elif hasattr(model, field_name):
+        if hasattr(model, field_name):
             return []
+        try:
+            model._meta.get_field(field_name)
+        except FieldDoesNotExist:
+            return [
+                checks.Error(
+                    "The value of '%s' is not a callable, an attribute of '%s', or an attribute of '%s.%s'." % (
+                        label, obj.__class__.__name__, model._meta.app_label, model._meta.object_name
+                    ),
+                    obj=obj.__class__,
+                    id='admin.E035',
+                )
+            ]
         else:
-            try:
-                model._meta.get_field(field_name)
-            except FieldDoesNotExist:
-                return [
-                    checks.Error(
-                        "The value of '%s' is not a callable, an attribute of '%s', or an attribute of '%s.%s'." % (
-                            label, obj.__class__.__name__, model._meta.app_label, model._meta.object_name
-                        ),
-                        obj=obj.__class__,
-                        id='admin.E035',
-                    )
-                ]
-            else:
-                return []
+            return []
 
 
 class ModelAdminChecks(BaseModelAdminChecks):
@@ -575 +551 @@
         if not isinstance(obj.save_as, bool):
             return must_be('a boolean', option='save_as',
                            obj=obj, id='admin.E101')
-        else:
-            return []
+        return []
 
     def _check_save_on_top(self, obj):
         """ Check save_on_top is a boolean. """
@@ -584 +559 @@
         if not isinstance(obj.save_on_top, bool):
             return must_be('a boolean', option='save_on_top',
                            obj=obj, id='admin.E102')
-        else:
-            return []
+        return []
 
     def _check_inlines(self, obj):
         """ Check all inline model admin classes. """
 
         if not isinstance(obj.inlines, (list, tuple)):
             return must_be('a list or tuple', option='inlines', obj=obj, id='admin.E103')
-        else:
-            return list(chain.from_iterable(
-                self._check_inlines_item(obj, obj.model, item, "inlines[%d]" % index)
-                for index, item in enumerate(obj.inlines)
-            ))
+        return list(chain.from_iterable(
+            self._check_inlines_item(obj, obj.model, item, "inlines[%d]" % index)
+            for index, item in enumerate(obj.inlines)
+        ))
 
     def _check_inlines_item(self, obj, model, inline, label):
         """ Check one inline model admin. """
@@ -612 +585 @@
                     id='admin.E104',
                 )
             ]
-        elif not inline.model:
+        if not inline.model:
             return [
                 checks.Error(
                     "'%s' must have a 'model' attribute." % inline_label,
@@ -620 +593 @@
                     id='admin.E105',
                 )
             ]
-        elif not issubclass(inline.model, models.Model):
+        if not issubclass(inline.model, models.Model):
             return must_be('a Model', option='%s.model' % inline_label, obj=obj, id='admin.E106')
-        else:
-            return inline(model, obj.admin_site).check()
+        return inline(model, obj.admin_site).check()
 
     def _check_list_display(self, obj):
         """ Check that list_display only contains fields or usable attributes.
@@ -631 +603 @@
 
         if not isinstance(obj.list_display, (list, tuple)):
             return must_be('a list or tuple', option='list_display', obj=obj, id='admin.E107')
-        else:
-            return list(chain.from_iterable(
-                self._check_list_display_item(obj, obj.model, item, "list_display[%d]" % index)
-                for index, item in enumerate(obj.list_display)
-            ))
+        return list(chain.from_iterable(
+            self._check_list_display_item(obj, obj.model, item, "list_display[%d]" % index)
+            for index, item in enumerate(obj.list_display)
+        ))
 
     def _check_list_display_item(self, obj, model, item, label):
         if callable(item):
             return []
-        elif hasattr(obj, item):
+        if hasattr(obj, item):
             return []
-        elif hasattr(model, item):
+        if hasattr(model, item):
             try:
                 field = model._meta.get_field(item)
             except FieldDoesNotExist:
@@ -657 +628 @@
                         )
                     ]
                 return []
-        else:
-            return [
-                checks.Error(
-                    "The value of '%s' refers to '%s', which is not a callable, "
-                    "an attribute of '%s', or an attribute or method on '%s.%s'." % (
-                        label, item, obj.__class__.__name__,
-                        model._meta.app_label, model._meta.object_name,
-                    ),
-                    obj=obj.__class__,
-                    id='admin.E108',
-                )
-            ]
+        return [
+            checks.Error(
+                "The value of '%s' refers to '%s', which is not a callable, "
+                "an attribute of '%s', or an attribute or method on '%s.%s'." % (
+                    label, item, obj.__class__.__name__,
+                    model._meta.app_label, model._meta.object_name,
+                ),
+                obj=obj.__class__,
+                id='admin.E108',
+            )
+        ]
 
     def _check_list_display_links(self, obj):
         """ Check that list_display_links is a unique subset of list_display.
@@ -677 +647 @@
 
         if obj.list_display_links is None:
             return []
-        elif not isinstance(obj.list_display_links, (list, tuple)):
+        if not isinstance(obj.list_display_links, (list, tuple)):
             return must_be('a list, a tuple, or None', option='list_display_links', obj=obj, id='admin.E110')
         # Check only if ModelAdmin.get_list_display() isn't overridden.
-        elif obj.get_list_display.__func__ is ModelAdmin.get_list_display:
+        if obj.get_list_display.__func__ is ModelAdmin.get_list_display:
             return list(chain.from_iterable(
                 self._check_list_display_links_item(obj, field_name, "list_display_links[%d]" % index)
                 for index, field_name in enumerate(obj.list_display_links)
@@ -698 +668 @@
                     id='admin.E111',
                 )
             ]
-        else:
-            return []
+        return []
 
     def _check_list_filter(self, obj):
         if not isinstance(obj.list_filter, (list, tuple)):
             return must_be('a list or tuple', option='list_filter', obj=obj, id='admin.E112')
-        else:
-            return list(chain.from_iterable(
-                self._check_list_filter_item(obj, obj.model, item, "list_filter[%d]" % index)
-                for index, item in enumerate(obj.list_filter)
-            ))
+        return list(chain.from_iterable(
+            self._check_list_filter_item(obj, obj.model, item, "list_filter[%d]" % index)
+            for index, item in enumerate(obj.list_filter)
+        ))
 
     def _check_list_filter_item(self, obj, model, item, label):
         """
@@ -727 +695 @@
                 return must_inherit_from(parent='ListFilter', option=label,
                                          obj=obj, id='admin.E113')
             # ...  but not a FieldListFilter.
-            elif issubclass(item, FieldListFilter):
+            if issubclass(item, FieldListFilter):
                 return [
                     checks.Error(
                         "The value of '%s' must not inherit from 'FieldListFilter'." % label,
@@ -735 +703 @@
                         id='admin.E114',
                     )
                 ]
-            else:
-                return []
-        elif isinstance(item, (tuple, list)):
+            return []
+        if isinstance(item, (tuple, list)):
             # item is option #2
             field, list_filter_class = item
             if not issubclass(list_filter_class, FieldListFilter):
                 return must_inherit_from(parent='FieldListFilter', option='%s[1]' % label, obj=obj, id='admin.E115')
-            else:
-                return []
-        else:
-            # item is option #1
-            field = item
+            return []
+        # item is option #1
+        field = item
 
-            # Validate the field string
-            try:
-                get_fields_from_path(model, field)
-            except (NotRelationField, FieldDoesNotExist):
-                return [
-                    checks.Error(
-                        "The value of '%s' refers to '%s', which does not refer to a Field." % (label, field),
-                        obj=obj.__class__,
-                        id='admin.E116',
-                    )
-                ]
-            else:
-                return []
+        # Validate the field string
+        try:
+            get_fields_from_path(model, field)
+        except (NotRelationField, FieldDoesNotExist):
+            return [
+                checks.Error(
+                    "The value of '%s' refers to '%s', which does not refer to a Field." % (label, field),
+                    obj=obj.__class__,
+                    id='admin.E116',
+                )
+            ]
+        else:
+            return []
 
     def _check_list_select_related(self, obj):
         """ Check that list_select_related is a boolean, a list or a tuple. """
 
         if not isinstance(obj.list_select_related, (bool, list, tuple)):
             return must_be('a boolean, tuple or list', option='list_select_related', obj=obj, id='admin.E117')
-        else:
-            return []
+        return []
 
     def _check_list_per_page(self, obj):
         """ Check that list_per_page is an integer. """
 
         if not isinstance(obj.list_per_page, int):
             return must_be('an integer', option='list_per_page', obj=obj, id='admin.E118')
-        else:
-            return []
+        return []
 
     def _check_list_max_show_all(self, obj):
         """ Check that list_max_show_all is an integer. """
 
         if not isinstance(obj.list_max_show_all, int):
             return must_be('an integer', option='list_max_show_all', obj=obj, id='admin.E119')
-        else:
-            return []
+        return []
 
     def _check_list_editable(self, obj):
         """ Check that list_editable is a sequence of editable fields from
@@ -792 +754 @@
 
         if not isinstance(obj.list_editable, (list, tuple)):
             return must_be('a list or tuple', option='list_editable', obj=obj, id='admin.E120')
-        else:
-            return list(chain.from_iterable(
-                self._check_list_editable_item(obj, obj.model, item, "list_editable[%d]" % index)
-                for index, item in enumerate(obj.list_editable)
-            ))
+        return list(chain.from_iterable(
+            self._check_list_editable_item(obj, obj.model, item, "list_editable[%d]" % index)
+            for index, item in enumerate(obj.list_editable)
+        ))
 
     def _check_list_editable_item(self, obj, model, field_name, label):
         try:
@@ -813 +774 @@
                         id='admin.E122',
                     )
                 ]
-            elif obj.list_display_links and field_name in obj.list_display_links:
+            if obj.list_display_links and field_name in obj.list_display_links:
                 return [
                     checks.Error(
                         "The value of '%s' cannot be in both 'list_editable' and 'list_display_links'." % field_name,
@@ -823 +784 @@
                 ]
             # If list_display[0] is in list_editable, check that
             # list_display_links is set. See #22792 and #26229 for use cases.
-            elif (obj.list_display[0] == field_name and not obj.list_display_links and
+            if (obj.list_display[0] == field_name and not obj.list_display_links and
                     obj.list_display_links is not None):
                 return [
                     checks.Error(
@@ -835 +796 @@
                         id='admin.E124',
                     )
                 ]
-            elif not field.editable:
+            if not field.editable:
                 return [
                     checks.Error(
                         "The value of '%s' refers to '%s', which is not editable through the admin." % (
@@ -845 +806 @@
                         id='admin.E125',
                     )
                 ]
-            else:
-                return []
+            return []
 
     def _check_search_fields(self, obj):
         """ Check search_fields is a sequence. """
 
         if not isinstance(obj.search_fields, (list, tuple)):
             return must_be('a list or tuple', option='search_fields', obj=obj, id='admin.E126')
-        else:
-            return []
+        return []
 
     def _check_date_hierarchy(self, obj):
         """ Check that date_hierarchy refers to DateField or DateTimeField. """
 
         if obj.date_hierarchy is None:
             return []
+        try:
+            field = get_fields_from_path(obj.model, obj.date_hierarchy)[-1]
+        except (NotRelationField, FieldDoesNotExist):
+            return [
+                checks.Error(
+                    "The value of 'date_hierarchy' refers to '%s', which "
+                    "does not refer to a Field." % obj.date_hierarchy,
+                    obj=obj.__class__,
+                    id='admin.E127',
+                )
+            ]
         else:
-            try:
-                field = get_fields_from_path(obj.model, obj.date_hierarchy)[-1]
-            except (NotRelationField, FieldDoesNotExist):
-                return [
-                    checks.Error(
-                        "The value of 'date_hierarchy' refers to '%s', which "
-                        "does not refer to a Field." % obj.date_hierarchy,
-                        obj=obj.__class__,
-                        id='admin.E127',
-                    )
-                ]
-            else:
-                if not isinstance(field, (models.DateField, models.DateTimeField)):
-                    return must_be('a DateField or DateTimeField', option='date_hierarchy', obj=obj, id='admin.E128')
-                else:
-                    return []
+            if not isinstance(field, (models.DateField, models.DateTimeField)):
+                return must_be('a DateField or DateTimeField', option='date_hierarchy', obj=obj, id='admin.E128')
+            return []
 
 
 class InlineModelAdminChecks(BaseModelAdminChecks):
@@ -919 +876 @@
                     id='admin.E201',
                 )
             ]
-        else:
-            return []
+        return []
 
     def _check_relation(self, obj, parent_model):
         try:
@@ -935 +891 @@
 
         if not isinstance(obj.extra, int):
             return must_be('an integer', option='extra', obj=obj, id='admin.E203')
-        else:
-            return []
+        return []
 
     def _check_max_num(self, obj):
         """ Check that max_num is an integer. """
 
         if obj.max_num is None:
             return []
-        elif not isinstance(obj.max_num, int):
+        if not isinstance(obj.max_num, int):
             return must_be('an integer', option='max_num', obj=obj, id='admin.E204')
-        else:
-            return []
+        return []
 
     def _check_min_num(self, obj):
         """ Check that min_num is an integer. """
 
         if obj.min_num is None:
             return []
-        elif not isinstance(obj.min_num, int):
+        if not isinstance(obj.min_num, int):
             return must_be('an integer', option='min_num', obj=obj, id='admin.E205')
-        else:
-            return []
+        return []
 
     def _check_formset(self, obj):
         """ Check formset is a subclass of BaseModelFormSet. """
 
         if not issubclass(obj.formset, BaseModelFormSet):
             return must_inherit_from(parent='BaseModelFormSet', option='formset', obj=obj, id='admin.E206')
-        else:
-            return []
+        return []
 
 
 def must_be(type, option, obj, id):

django/contrib/admin/models.py

@@ -68 +68 @@
     def __str__(self):
         if self.is_addition():
             return gettext('Added "%(object)s".') % {'object': self.object_repr}
-        elif self.is_change():
+        if self.is_change():
             return gettext('Changed "%(object)s" - %(changes)s') % {
                 'object': self.object_repr,
                 'changes': self.get_change_message(),
             }
-        elif self.is_deletion():
+        if self.is_deletion():
             return gettext('Deleted "%(object)s."') % {'object': self.object_repr}
 
         return gettext('LogEntry Object')

django/contrib/admin/options.py

@@ -939 +939 @@
         def construct_search(field_name):
             if field_name.startswith('^'):
                 return "%s__istartswith" % field_name[1:]
-            elif field_name.startswith('='):
+            if field_name.startswith('='):
                 return "%s__iexact" % field_name[1:]
-            elif field_name.startswith('@'):
+            if field_name.startswith('@'):
                 return "%s__search" % field_name[1:]
             # Use field_name if it includes a lookup.
             opts = queryset.model._meta

django/contrib/admin/templatetags/admin_list.py

@@ -31 +31 @@
     """
     if i == DOT:
         return '... '
-    elif i == cl.page_num:
+    if i == cl.page_num:
         return format_html('<span class="this-page">{}</span> ', i + 1)
-    else:
-        return format_html('<a href="{}"{}>{}</a> ',
-                           cl.get_query_string({PAGE_VAR: i}),
-                           mark_safe(' class="end"' if i == cl.paginator.num_pages - 1 else ''),
-                           i + 1)
+    return format_html('<a href="{}"{}>{}</a> ',
+                       cl.get_query_string({PAGE_VAR: i}),
+                       mark_safe(' class="end"' if i == cl.paginator.num_pages - 1 else ''),
+                       i + 1)
 
 
 @register.inclusion_tag('admin/pagination.html')

django/contrib/admin/utils.py

@@ -393 +393 @@
         return dict(field.flatchoices).get(value, empty_value_display)
     # NullBooleanField needs special-case null-handling, so it comes
     # before the general null test.
-    elif isinstance(field, (models.BooleanField, models.NullBooleanField)):
+    if isinstance(field, (models.BooleanField, models.NullBooleanField)):
         return _boolean_icon(value)
-    elif value is None:
+    if value is None:
         return empty_value_display
-    elif isinstance(field, models.DateTimeField):
+    if isinstance(field, models.DateTimeField):
         return formats.localize(timezone.template_localtime(value))
-    elif isinstance(field, (models.DateField, models.TimeField)):
+    if isinstance(field, (models.DateField, models.TimeField)):
         return formats.localize(value)
-    elif isinstance(field, models.DecimalField):
+    if isinstance(field, models.DecimalField):
         return formats.number_format(value, field.decimal_places)
-    elif isinstance(field, (models.IntegerField, models.FloatField)):
+    if isinstance(field, (models.IntegerField, models.FloatField)):
         return formats.number_format(value)
-    elif isinstance(field, models.FileField) and value:
+    if isinstance(field, models.FileField) and value:
         return format_html('<a href="{}">{}</a>', value.url, value)
-    else:
-        return display_for_value(value, empty_value_display)
+    return display_for_value(value, empty_value_display)
 
 
 def display_for_value(value, empty_value_display, boolean=False):
@@ -416 +415 @@
 
     if boolean:
         return _boolean_icon(value)
-    elif value is None:
+    if value is None:
         return empty_value_display
-    elif isinstance(value, datetime.datetime):
+    if isinstance(value, datetime.datetime):
         return formats.localize(timezone.template_localtime(value))
-    elif isinstance(value, (datetime.date, datetime.time)):
+    if isinstance(value, (datetime.date, datetime.time)):
         return formats.localize(value)
-    elif isinstance(value, (int, decimal.Decimal, float)):
+    if isinstance(value, (int, decimal.Decimal, float)):
         return formats.number_format(value)
-    elif isinstance(value, (list, tuple)):
+    if isinstance(value, (list, tuple)):
         return ', '.join(str(v) for v in value)
-    else:
-        return str(value)
+    return str(value)
 
 
 class NotRelationField(Exception):
@@ -437 +435 @@
 def get_model_from_relation(field):
     if hasattr(field, 'get_path_info'):
         return field.get_path_info()[-1].to_opts.model
-    else:
-        raise NotRelationField
+    raise NotRelationField
 
 
 def reverse_field_path(model, path):

django/contrib/admindocs/views.py

@@ -372 +372 @@
     if func_name.startswith('get_'):
         if func_name.endswith('_list'):
             return 'List'
-        elif func_name.endswith('_count'):
+        if func_name.endswith('_count'):
             return 'Integer'
     return ''
 

django/contrib/auth/forms.py

@@ -202 +202 @@
                 else:
                     self.confirm_login_allowed(self.user_cache)
                 raise self.get_invalid_login_error()
-            else:
-                self.confirm_login_allowed(self.user_cache)
+            self.confirm_login_allowed(self.user_cache)
 
         return self.cleaned_data
 

django/contrib/auth/hashers.py

@@ -115 +115 @@
     if hasattr(algorithm, 'algorithm'):
         return algorithm
 
-    elif algorithm == 'default':
+    if algorithm == 'default':
         return get_hashers()[0]
 
-    else:
-        hashers = get_hashers_by_algorithm()
-        try:
-            return hashers[algorithm]
-        except KeyError:
-            raise ValueError("Unknown password hashing algorithm '%s'. "
-                             "Did you specify it in the PASSWORD_HASHERS "
-                             "setting?" % algorithm)
+    hashers = get_hashers_by_algorithm()
+    try:
+        return hashers[algorithm]
+    except KeyError:
+        raise ValueError("Unknown password hashing algorithm '%s'. "
+                         "Did you specify it in the PASSWORD_HASHERS "
+                         "setting?" % algorithm)
 
 
 def identify_hasher(encoded):

django/contrib/contenttypes/fields.py

@@ -138 +138 @@
                         id='contenttypes.E003',
                     )
                 ]
-            elif field.remote_field.model != ContentType:
+            if field.remote_field.model != ContentType:
                 return [
                     checks.Error(
                         "'%s.%s' is not a ForeignKey to 'contenttypes.ContentType'." % (
@@ -152 +152 @@
                         id='contenttypes.E004',
                     )
                 ]
-            else:
-                return []
+            return []
 
     def get_cache_name(self):
         return self.name
@@ -162 +161 @@
         if obj is not None:
             return ContentType.objects.db_manager(obj._state.db).get_for_model(
                 obj, for_concrete_model=self.for_concrete_model)
-        elif id is not None:
+        if id is not None:
             return ContentType.objects.db_manager(using).get_for_id(id)
-        else:
-            # This should never happen. I love comments like this, don't you?
-            raise Exception("Impossible arguments to GFK.get_content_type!")
+        # This should never happen. I love comments like this, don't you?
+        raise Exception("Impossible arguments to GFK.get_content_type!")
 
     def get_prefetch_queryset(self, instances, queryset=None):
         if queryset is not None:

django/contrib/gis/db/backends/base/models.py

@@ -96 +96 @@
         "Return a tuple of the units and the name."
         if self.projected or self.local:
             return (self.linear_units, self.linear_name)
-        elif self.geographic:
+        if self.geographic:
             return (self.angular_units, self.angular_name)
-        else:
-            return (None, None)
+        return (None, None)
 
     @classmethod
     def get_units(cls, wkt):

django/contrib/gis/db/backends/base/operations.py

@@ -98 +98 @@
                 self.spatial_function_name('Transform'),
                 self.from_text, value.srid, f.srid,
             )
-        elif self.connection.features.has_spatialrefsys_table:
+        if self.connection.features.has_spatialrefsys_table:
             return '%s(%%s,%s)' % (self.from_text, f.srid)
-        else:
-            # For backwards compatibility on MySQL (#27464).
-            return '%s(%%s)' % self.from_text
+        # For backwards compatibility on MySQL (#27464).
+        return '%s(%%s)' % self.from_text
 
     def check_expression_support(self, expression):
         if isinstance(expression, self.disallowed_aggregates):
@@ -145 +144 @@
             if self.connection.features.supports_area_geodetic:
                 return 'sq_m'
             raise NotImplementedError('Area on geodetic coordinate systems not supported.')
-        else:
-            units_name = field.units_name(self.connection)
-            if units_name:
-                return AreaMeasure.unit_attname(units_name)
+        units_name = field.units_name(self.connection)
+        if units_name:
+            return AreaMeasure.unit_attname(units_name)
 
     def get_distance_att_for_field(self, field):
         dist_att = None

django/contrib/gis/db/models/lookups.py

@@ -283 +283 @@
     def process_rhs_params(self):
         if not 1 <= len(self.rhs_params) <= 3:
             raise ValueError("2, 3, or 4-element tuple required for '%s' lookup." % self.lookup_name)
-        elif len(self.rhs_params) == 3 and self.rhs_params[2] != 'spheroid':
+        if len(self.rhs_params) == 3 and self.rhs_params[2] != 'spheroid':
             raise ValueError("For 4-element tuples the last argument must be the 'spheroid' directive.")
 
         # Check if the second parameter is a band index.

django/contrib/gis/gdal/envelope.py

@@ -48 +48 @@
                 # A tuple was passed in.
                 if len(args[0]) != 4:
                     raise GDALException('Incorrect number of tuple elements (%d).' % len(args[0]))
-                else:
-                    self._from_sequence(args[0])
+                self._from_sequence(args[0])
             else:
                 raise TypeError('Incorrect type of argument: %s' % type(args[0]))
         elif len(args) == 4:
@@ -73 +72 @@
         if isinstance(other, Envelope):
             return (self.min_x == other.min_x) and (self.min_y == other.min_y) and \
                    (self.max_x == other.max_x) and (self.max_y == other.max_y)
-        elif isinstance(other, tuple) and len(other) == 4:
+        if isinstance(other, tuple) and len(other) == 4:
             return (self.min_x == other[0]) and (self.min_y == other[1]) and \
                    (self.max_x == other[2]) and (self.max_y == other[3])
-        else:
-            raise GDALException('Equivalence testing only works with other Envelopes.')
+        raise GDALException('Equivalence testing only works with other Envelopes.')
 
     def __str__(self):
         "Return a string representation of the tuple."
@@ -104 +102 @@
         if len(args) == 1:
             if isinstance(args[0], Envelope):
                 return self.expand_to_include(args[0].tuple)
-            elif hasattr(args[0], 'x') and hasattr(args[0], 'y'):
+            if hasattr(args[0], 'x') and hasattr(args[0], 'y'):
                 return self.expand_to_include(args[0].x, args[0].y, args[0].x, args[0].y)
-            elif isinstance(args[0], (tuple, list)):
+            if isinstance(args[0], (tuple, list)):
                 # A tuple was passed in.
                 if len(args[0]) == 2:
                     return self.expand_to_include((args[0][0], args[0][1], args[0][0], args[0][1]))
-                elif len(args[0]) == 4:
+                if len(args[0]) == 4:
                     (minx, miny, maxx, maxy) = args[0]
                     if minx < self._envelope.MinX:
                         self._envelope.MinX = minx
@@ -126 +124 @@
                 raise TypeError('Incorrect type of argument: %s' % type(args[0]))
         elif len(args) == 2:
             # An x and an y parameter were passed in
-                return self.expand_to_include((args[0], args[1], args[0], args[1]))
+            return self.expand_to_include((args[0], args[1], args[0], args[1]))
         elif len(args) == 4:
             # Individual parameters passed in.
             return self.expand_to_include(args)

django/contrib/gis/gdal/error.py

@@ -54 +54 @@
 
     if code == ERR_NONE:
         return
-    elif code in err_dict:
+    if code in err_dict:
         e, msg = err_dict[code]
         raise e(msg)
-    else:
-        raise GDALException('Unknown error code: "%s"' % code)
+    raise GDALException('Unknown error code: "%s"' % code)

django/contrib/gis/gdal/geometries.py

@@ -541 +541 @@
         "Return the tuple of this point."
         if self.coord_dim == 2:
             return (self.x, self.y)
-        elif self.coord_dim == 3:
+        if self.coord_dim == 3:
             return (self.x, self.y, self.z)
     coords = tuple
 
@@ -556 +556 @@
             dim = self.coord_dim
             if dim == 1:
                 return (x.value,)
-            elif dim == 2:
+            if dim == 2:
                 return (x.value, y.value)
-            elif dim == 3:
+            if dim == 3:
                 return (x.value, y.value, z.value)
         else:
             raise IndexError('Index out of range when accessing points of a line string: %s.' % index)

django/contrib/gis/gdal/geomtype.py

@@ -61 +61 @@
         """
         if isinstance(other, OGRGeomType):
             return self.num == other.num
-        elif isinstance(other, str):
+        if isinstance(other, str):
             return self.name.lower() == other.lower()
-        elif isinstance(other, int):
+        if isinstance(other, int):
             return self.num == other
-        else:
-            return False
+        return False
 
     @property
     def name(self):

django/contrib/gis/gdal/srs.py

@@ -82 +82 @@
         # If the pointer is NULL, throw an exception.
         if not srs:
             raise SRSException('Could not create spatial reference from: %s' % srs_input)
-        else:
-            self.ptr = srs
+        self.ptr = srs
 
         # Importing from either the user input string or an integer SRID.
         if srs_type == 'user':
@@ -170 +169 @@
         "Return the name of this Spatial Reference."
         if self.projected:
             return self.attr_value('PROJCS')
-        elif self.geographic:
+        if self.geographic:
             return self.attr_value('GEOGCS')
-        elif self.local:
+        if self.local:
             return self.attr_value('LOCAL_CS')
-        else:
-            return None
+        return None
 
     @property
     def srid(self):

django/contrib/gis/geoip2/base.py

@@ -115 +115 @@
 
     @property
     def _reader(self):
-        if self._country:
-            return self._country
-        else:
-            return self._city
+        return self._country or self._city
 
     @property
     def _country_or_city(self):
         if self._country:
             return self._country.country
-        else:
-            return self._city.city
+        return self._city.city
 
     def __del__(self):
         # Cleanup any GeoIP file handles lying around.
@@ -151 +147 @@
         # Extra checks for the existence of country and city databases.
         if city_or_country and not (self._country or self._city):
             raise GeoIP2Exception('Invalid GeoIP country and city data files.')
-        elif country and not self._country:
+        if country and not self._country:
             raise GeoIP2Exception('Invalid GeoIP country data file: %s' % self._country_file)
-        elif city and not self._city:
+        if city and not self._city:
             raise GeoIP2Exception('Invalid GeoIP city data file: %s' % self._city_file)
 
         # Return the query string back to the caller. GeoIP2 only takes IP addresses.

django/contrib/gis/geos/mutable_list.py

@@ -160 +160 @@
                 return True
             if c:
                 return c
-            elif other[i] < self[i]:
+            if other[i] < self[i]:
                 return False
         return len(self) < olen
 

django/contrib/gis/geos/point.py

@@ -91 +91 @@
             return 0
         if self.hasz:
             return 3
-        else:
-            return 2
+        return 2
 
     def _get_single_external(self, index):
         if index == 0:
             return self.x
-        elif index == 1:
+        if index == 1:
             return self.y
-        elif index == 2:
+        if index == 2:
             return self.z
 
     _get_single_internal = _get_single_external

django/contrib/gis/geos/prototypes/errcheck.py

@@ -45 +45 @@
     "Error checking for unary/binary predicate functions."
     if result == 1:
         return True
-    elif result == 0:
+    if result == 0:
         return False
-    else:
-        raise GEOSException('Error encountered on GEOS C predicate function "%s".' % func.__name__)
+    raise GEOSException('Error encountered on GEOS C predicate function "%s".' % func.__name__)
 
 
 def check_sized_string(result, func, cargs):

django/contrib/gis/geos/prototypes/io.py

@@ -147 +147 @@
         if isinstance(wkb, memoryview):
             wkb_s = bytes(wkb)
             return wkb_reader_read(self.ptr, wkb_s, len(wkb_s))
-        elif isinstance(wkb, (bytes, str)):
+        if isinstance(wkb, (bytes, str)):
             return wkb_reader_read_hex(self.ptr, wkb, len(wkb))
-        else:
-            raise TypeError
+        raise TypeError
 
 
 # ### WKB/WKT Writer Classes ###

django/contrib/gis/measure.py

@@ -209 +209 @@
         lower = unit_str.lower()
         if unit_str in cls.UNITS:
             return unit_str
-        elif lower in cls.UNITS:
+        if lower in cls.UNITS:
             return lower
-        elif lower in cls.LALIAS:
+        if lower in cls.LALIAS:
             return cls.LALIAS[lower]
-        else:
-            raise Exception('Could not find a unit keyword associated with "%s"' % unit_str)
+        raise Exception('Could not find a unit keyword associated with "%s"' % unit_str)
 
 
 class Distance(MeasureBase):
@@ -300 +299 @@
                 default_unit=AREA_PREFIX + self._default_unit,
                 **{AREA_PREFIX + self.STANDARD_UNIT: (self.standard * other.standard)}
             )
-        elif isinstance(other, NUMERIC_TYPES):
+        if isinstance(other, NUMERIC_TYPES):
             return self.__class__(
                 default_unit=self._default_unit,
                 **{self.STANDARD_UNIT: (self.standard * other)}
             )
-        else:
-            raise TypeError('%(distance)s must be multiplied with number or %(distance)s' % {
-                "distance": pretty_name(self.__class__),
-            })
+        raise TypeError('%(distance)s must be multiplied with number or %(distance)s' % {
+            "distance": pretty_name(self.__class__),
+        })
 
 
 class Area(MeasureBase):

django/contrib/gis/utils/layermapping.py

@@ -154 +154 @@
         if fid_range:
             if isinstance(fid_range, (tuple, list)):
                 return slice(*fid_range)
-            elif isinstance(fid_range, slice):
+            if isinstance(fid_range, slice):
                 return fid_range
-            else:
-                raise TypeError
-        else:
-            return None
+            raise TypeError
+        return None
 
     def check_layer(self):
         """

django/contrib/gis/utils/ogrinspect.py

@@ -144 +144 @@
     def process_kwarg(kwarg):
         if isinstance(kwarg, (list, tuple)):
             return [s.lower() for s in kwarg]
-        elif kwarg:
+        if kwarg:
             return [s.lower() for s in ogr_fields]
-        else:
-            return []
+        return []
     null_fields = process_kwarg(null)
     blank_fields = process_kwarg(blank)
     decimal_fields = process_kwarg(decimal)
@@ -161 +160 @@
             kwlist.append('blank=True')
         if kwlist:
             return ', ' + ', '.join(kwlist)
-        else:
-            return ''
+        return ''
 
     # For those wishing to disable the imports.
     if imports:

django/contrib/humanize/templatetags/humanize.py

@@ -173 +173 @@
     delta = value - today
     if delta.days == 0:
         return _('today')
-    elif delta.days == 1:
+    if delta.days == 1:
         return _('tomorrow')
-    elif delta.days == -1:
+    if delta.days == -1:
         return _('yesterday')
     return defaultfilters.date(value, arg)
 
@@ -198 +198 @@
             return pgettext(
                 'naturaltime', '%(delta)s ago'
             ) % {'delta': defaultfilters.timesince(value, now)}
-        elif delta.seconds == 0:
+        if delta.seconds == 0:
             return _('now')
-        elif delta.seconds < 60:
+        if delta.seconds < 60:
             return ngettext(
                 # Translators: please keep a non-breaking space (U+00A0)
                 # between count and time unit.
                 'a second ago', '%(count)s seconds ago', delta.seconds
             ) % {'count': delta.seconds}
-        elif delta.seconds // 60 < 60:
+        if delta.seconds // 60 < 60:
             count = delta.seconds // 60
             return ngettext(
                 # Translators: please keep a non-breaking space (U+00A0)
                 # between count and time unit.
                 'a minute ago', '%(count)s minutes ago', count
             ) % {'count': count}
-        else:
-            count = delta.seconds // 60 // 60
-            return ngettext(
-                # Translators: please keep a non-breaking space (U+00A0)
-                # between count and time unit.
-                'an hour ago', '%(count)s hours ago', count
-            ) % {'count': count}
-    else:
-        delta = value - now
-        if delta.days != 0:
-            return pgettext(
-                'naturaltime', '%(delta)s from now'
-            ) % {'delta': defaultfilters.timeuntil(value, now)}
-        elif delta.seconds == 0:
-            return _('now')
-        elif delta.seconds < 60:
-            return ngettext(
-                # Translators: please keep a non-breaking space (U+00A0)
-                # between count and time unit.
-                'a second from now', '%(count)s seconds from now', delta.seconds
-            ) % {'count': delta.seconds}
-        elif delta.seconds // 60 < 60:
-            count = delta.seconds // 60
-            return ngettext(
-                # Translators: please keep a non-breaking space (U+00A0)
-                # between count and time unit.
-                'a minute from now', '%(count)s minutes from now', count
-            ) % {'count': count}
-        else:
-            count = delta.seconds // 60 // 60
-            return ngettext(
-                # Translators: please keep a non-breaking space (U+00A0)
-                # between count and time unit.
-                'an hour from now', '%(count)s hours from now', count
-            ) % {'count': count}
+        count = delta.seconds // 60 // 60
+        return ngettext(
+            # Translators: please keep a non-breaking space (U+00A0)
+            # between count and time unit.
+            'an hour ago', '%(count)s hours ago', count
+        ) % {'count': count}
+    delta = value - now
+    if delta.days != 0:
+        return pgettext(
+            'naturaltime', '%(delta)s from now'
+        ) % {'delta': defaultfilters.timeuntil(value, now)}
+    if delta.seconds == 0:
+        return _('now')
+    if delta.seconds < 60:
+        return ngettext(
+            # Translators: please keep a non-breaking space (U+00A0)
+            # between count and time unit.
+            'a second from now', '%(count)s seconds from now', delta.seconds
+        ) % {'count': delta.seconds}
+    if delta.seconds // 60 < 60:
+        count = delta.seconds // 60
+        return ngettext(
+            # Translators: please keep a non-breaking space (U+00A0)
+            # between count and time unit.
+            'a minute from now', '%(count)s minutes from now', count
+        ) % {'count': count}
+    count = delta.seconds // 60 // 60
+    return ngettext(
+        # Translators: please keep a non-breaking space (U+00A0)
+        # between count and time unit.
+        'an hour from now', '%(count)s hours from now', count
+    ) % {'count': count}

django/contrib/postgres/fields/ranges.py

@@ -38 +38 @@
     def get_prep_value(self, value):
         if value is None:
             return None
-        elif isinstance(value, Range):
+        if isinstance(value, Range):
             return value
-        elif isinstance(value, (list, tuple)):
+        if isinstance(value, (list, tuple)):
             return self.range_type(value[0], value[1])
         return value
 

django/contrib/postgres/forms/jsonb.py

@@ -25 +25 @@
             return value
         if value in self.empty_values:
             return None
-        elif isinstance(value, (list, dict, int, float, JSONString)):
+        if isinstance(value, (list, dict, int, float, JSONString)):
             return value
         try:
             converted = json.loads(value)
@@ -37 +37 @@
             )
         if isinstance(converted, str):
             return JSONString(converted)
-        else:
-            return converted
+        return converted
 
     def bound_data(self, data, initial):
         if self.disabled:

django/contrib/sessions/backends/base.py

@@ -103 +103 @@
             # could produce ValueError if there is no ':'
             hash, serialized = encoded_data.split(b':', 1)
             expected_hash = self._hash(serialized)
-            if not constant_time_compare(hash.decode(), expected_hash):
-                raise SuspiciousSession("Session data corrupted")
-            else:
+            if constant_time_compare(hash.decode(), expected_hash):
                 return self.serializer().loads(serialized)
+            raise SuspiciousSession("Session data corrupted")
         except Exception as e:
             # ValueError, SuspiciousOperation, unpickling exceptions. If any of
             # these happen, just return an empty dictionary (an empty session).

django/contrib/sites/models.py

@@ -58 +58 @@
         if getattr(settings, 'SITE_ID', ''):
             site_id = settings.SITE_ID
             return self._get_site_by_id(site_id)
-        elif request:
+        if request:
             return self._get_site_by_request(request)
 
         raise ImproperlyConfigured(

django/core/checks/registry.py

@@ -50 +50 @@
 
         if callable(check):
             return inner(check)
-        else:
-            if check:
-                tags += (check, )
-            return inner
+        if check:
+            tags += (check, )
+        return inner
 
     def run_checks(self, app_configs=None, tags=None, include_deployment_checks=False):
         """

django/core/checks/urls.py

@@ -21 +21 @@
     check_method = getattr(resolver, 'check', None)
     if check_method is not None:
         return check_method()
-    elif not hasattr(resolver, 'resolve'):
+    if not hasattr(resolver, 'resolve'):
         return get_warning_for_invalid_pattern(resolver)
-    else:
-        return []
+    return []
 
 
 @register(Tags.urls)

django/core/management/base.py

@@ -408 +408 @@
         if any(e.is_serious(fail_level) and not e.is_silenced() for e in all_issues):
             msg = self.style.ERROR("SystemCheckError: %s" % header) + body + footer
             raise SystemCheckError(msg)
-        else:
-            msg = header + body + footer
+        msg = header + body + footer
 
         if msg:
             if visible_issue_count:

django/core/serializers/json.py

@@ -87 +87 @@
             if r.endswith('+00:00'):
                 r = r[:-6] + 'Z'
             return r
-        elif isinstance(o, datetime.date):
+        if isinstance(o, datetime.date):
             return o.isoformat()
-        elif isinstance(o, datetime.time):
+        if isinstance(o, datetime.time):
             if is_aware(o):
                 raise ValueError("JSON can't represent timezone-aware times.")
             r = o.isoformat()
             if o.microsecond:
                 r = r[:12]
             return r
-        elif isinstance(o, datetime.timedelta):
+        if isinstance(o, datetime.timedelta):
             return duration_iso_string(o)
-        elif isinstance(o, (decimal.Decimal, uuid.UUID, Promise)):
+        if isinstance(o, (decimal.Decimal, uuid.UUID, Promise)):
             return str(o)
-        else:
-            return super().default(o)
+        return super().default(o)

django/db/backends/base/base.py

@@ -125 +125 @@
         """
         if not settings.USE_TZ:
             return None
-        elif self.features.supports_timezones:
+        if self.features.supports_timezones:
             return None
-        elif self.settings_dict['TIME_ZONE'] is None:
+        if self.settings_dict['TIME_ZONE'] is None:
             return timezone.utc
-        else:
-            return pytz.timezone(self.settings_dict['TIME_ZONE'])
+        return pytz.timezone(self.settings_dict['TIME_ZONE'])
 
     @cached_property
     def timezone_name(self):
@@ -139 +138 @@
         """
         if not settings.USE_TZ:
             return settings.TIME_ZONE
-        elif self.settings_dict['TIME_ZONE'] is None:
+        if self.settings_dict['TIME_ZONE'] is None:
             return 'UTC'
-        else:
-            return self.settings_dict['TIME_ZONE']
+        return self.settings_dict['TIME_ZONE']
 
     @property
     def queries_logged(self):
@@ -204 +202 @@
                 raise ImproperlyConfigured(
                     "Connection '%s' cannot set TIME_ZONE because USE_TZ is "
                     "False." % self.alias)
-            elif self.features.supports_timezones:
+            if self.features.supports_timezones:
                 raise ImproperlyConfigured(
                     "Connection '%s' cannot set TIME_ZONE because its engine "
                     "handles time zones conversions natively." % self.alias)

django/db/backends/base/operations.py

@@ -167 +167 @@
         """
         if fields:
             raise NotSupportedError('DISTINCT ON fields is not supported by this database backend')
-        else:
-            return 'DISTINCT'
+        return 'DISTINCT'
 
     def fetch_returned_insert_id(self, cursor):
         """
@@ -208 +207 @@
         offset = low_mark or 0
         if high_mark is not None:
             return (high_mark - offset), offset
-        elif offset:
+        if offset:
             return self.connection.ops.no_limit_value(), offset
         return None, offset
 
@@ -473 +472 @@
         """
         if isinstance(value, datetime.datetime):   # must be before date
             return self.adapt_datetimefield_value(value)
-        elif isinstance(value, datetime.date):
+        if isinstance(value, datetime.date):
             return self.adapt_datefield_value(value)
-        elif isinstance(value, datetime.time):
+        if isinstance(value, datetime.time):
             return self.adapt_timefield_value(value)
-        elif isinstance(value, decimal.Decimal):
+        if isinstance(value, decimal.Decimal):
             return self.adapt_decimalfield_value(value)
-        else:
-            return value
+        return value
 
     def adapt_datefield_value(self, value):
         """
@@ -629 +627 @@
         if isinstance(start, int):
             if start < 0:
                 return '%d %s' % (abs(start), self.PRECEDING)
-            elif start == 0:
+            if start == 0:
                 return self.CURRENT_ROW
-        elif start is None:
+        if start is None:
             return self.UNBOUNDED_PRECEDING
         raise ValueError("start argument must be a negative integer, zero, or None, but got '%s'." % start)
 
@@ -639 +637 @@
         if isinstance(end, int):
             if end == 0:
                 return self.CURRENT_ROW
-            elif end > 0:
+            if end > 0:
                 return '%d %s' % (end, self.FOLLOWING)
-        elif end is None:
+        if end is None:
             return self.UNBOUNDED_FOLLOWING
         raise ValueError("end argument must be a positive integer, zero, or None, but got '%s'." % end)
 

django/db/backends/base/schema.py

@@ -487 +487 @@
                 "db_type (are you using a badly-written custom field?)" %
                 (old_field, new_field),
             )
-        elif old_type is None and new_type is None and (
+        if old_type is None and new_type is None and (
                 old_field.remote_field.through and new_field.remote_field.through and
                 old_field.remote_field.through._meta.auto_created and
                 new_field.remote_field.through._meta.auto_created):
             return self._alter_many_to_many(model, old_field, new_field, strict)
-        elif old_type is None and new_type is None and (
+        if old_type is None and new_type is None and (
                 old_field.remote_field.through and new_field.remote_field.through and
                 not old_field.remote_field.through._meta.auto_created and
                 not new_field.remote_field.through._meta.auto_created):
             # Both sides have through models; this is a no-op.
             return
-        elif old_type is None or new_type is None:
+        if old_type is None or new_type is None:
             raise ValueError(
                 "Cannot alter field %s into %s - they are not compatible types "
                 "(you cannot alter to or from M2M fields, or add or remove "

django/db/backends/mysql/introspection.py

@@ -41 +41 @@
         if 'auto_increment' in description.extra:
             if field_type == 'IntegerField':
                 return 'AutoField'
-            elif field_type == 'BigIntegerField':
+            if field_type == 'BigIntegerField':
                 return 'BigAutoField'
         if description.is_unsigned:
             if field_type == 'IntegerField':
                 return 'PositiveIntegerField'
-            elif field_type == 'SmallIntegerField':
+            if field_type == 'SmallIntegerField':
                 return 'PositiveSmallIntegerField'
         return field_type
 

django/db/backends/mysql/operations.py

@@ -49 +49 @@
         if lookup_type in fields:
             format_str = fields[lookup_type]
             return "CAST(DATE_FORMAT(%s, '%s') AS DATE)" % (field_name, format_str)
-        elif lookup_type == 'quarter':
+        if lookup_type == 'quarter':
             return "MAKEDATE(YEAR(%s), 1) + INTERVAL QUARTER(%s) QUARTER - INTERVAL 1 QUARTER" % (
                 field_name, field_name
             )
-        else:
-            return "DATE(%s)" % (field_name)
+        return "DATE(%s)" % (field_name)
 
     def _convert_field_to_tz(self, field_name, tzname):
         if settings.USE_TZ:
@@ -204 +203 @@
             return 'POW(%s)' % ','.join(sub_expressions)
         # Convert the result to a signed integer since MySQL's binary operators
         # return an unsigned integer.
-        elif connector in ('&', '|', '<<'):
+        if connector in ('&', '|', '<<'):
             return 'CONVERT(%s, SIGNED)' % connector.join(sub_expressions)
-        elif connector == '>>':
+        if connector == '>>':
             lhs, rhs = sub_expressions
             return 'FLOOR(%(lhs)s / POW(2, %(rhs)s))' % {'lhs': lhs, 'rhs': rhs}
         return super().combine_expression(connector, sub_expressions)

django/db/backends/oracle/introspection.py

@@ -34 +34 @@
             if scale == 0:
                 if precision > 11:
                     return 'BigAutoField' if description.is_autofield else 'BigIntegerField'
-                elif precision == 1:
+                if precision == 1:
                     return 'BooleanField'
-                elif description.is_autofield:
+                if description.is_autofield:
                     return 'AutoField'
-                else:
-                    return 'IntegerField'
-            elif scale == -127:
+                return 'IntegerField'
+            if scale == -127:
                 return 'FloatField'
 
         return super().get_field_type(data_type, description)

django/db/backends/oracle/operations.py

@@ -62 +62 @@
         if lookup_type == 'week_day':
             # TO_CHAR(field, 'D') returns an integer from 1-7, where 1=Sunday.
             return "TO_CHAR(%s, 'D')" % field_name
-        elif lookup_type == 'week':
+        if lookup_type == 'week':
             # IW = ISO week number
             return "TO_CHAR(%s, 'IW')" % field_name
-        elif lookup_type == 'quarter':
+        if lookup_type == 'quarter':
             return "TO_CHAR(%s, 'Q')" % field_name
-        else:
-            # https://docs.oracle.com/database/121/SQLRF/functions067.htm#SQLRF00639
-            return "EXTRACT(%s FROM %s)" % (lookup_type.upper(), field_name)
+        # https://docs.oracle.com/database/121/SQLRF/functions067.htm#SQLRF00639
+        return "EXTRACT(%s FROM %s)" % (lookup_type.upper(), field_name)
 
     def date_interval_sql(self, timedelta):
         """
@@ -81 +80 @@
         # https://docs.oracle.com/database/121/SQLRF/functions271.htm#SQLRF52058
         if lookup_type in ('year', 'month'):
             return "TRUNC(%s, '%s')" % (field_name, lookup_type.upper())
-        elif lookup_type == 'quarter':
+        if lookup_type == 'quarter':
             return "TRUNC(%s, 'Q')" % field_name
-        else:
-            return "TRUNC(%s)" % field_name
+        return "TRUNC(%s)" % field_name
 
     # Oracle crashes with "ORA-03113: end-of-file on communication channel"
     # if the time zone name is passed in parameter. Use interpolation instead.
@@ -505 +503 @@
         lhs, rhs = sub_expressions
         if connector == '%%':
             return 'MOD(%s)' % ','.join(sub_expressions)
-        elif connector == '&':
+        if connector == '&':
             return 'BITAND(%s)' % ','.join(sub_expressions)
-        elif connector == '|':
+        if connector == '|':
             return 'BITAND(-%(lhs)s-1,%(rhs)s)+%(lhs)s' % {'lhs': lhs, 'rhs': rhs}
-        elif connector == '<<':
+        if connector == '<<':
             return '(%(lhs)s * POWER(2, %(rhs)s))' % {'lhs': lhs, 'rhs': rhs}
-        elif connector == '>>':
+        if connector == '>>':
             return 'FLOOR(%(lhs)s / POWER(2, %(rhs)s))' % {'lhs': lhs, 'rhs': rhs}
-        elif connector == '^':
+        if connector == '^':
             return 'POWER(%s)' % ','.join(sub_expressions)
         return super().combine_expression(connector, sub_expressions)
 

django/db/backends/oracle/schema.py

@@ -20 +20 @@
     def quote_value(self, value):
         if isinstance(value, (datetime.date, datetime.time, datetime.datetime)):
             return "'%s'" % value
-        elif isinstance(value, str):
+        if isinstance(value, str):
             return "'%s'" % value.replace("\'", "\'\'")
-        elif isinstance(value, (bytes, bytearray, memoryview)):
+        if isinstance(value, (bytes, bytearray, memoryview)):
             return "'%s'" % value.hex()
-        elif isinstance(value, bool):
+        if isinstance(value, bool):
             return "1" if value else "0"
-        else:
-            return str(value)
+        return str(value)
 
     def remove_field(self, model, field):
         # If the column is an identity column, drop the identity before

django/db/backends/postgresql/introspection.py

@@ -44 +44 @@
         if description.default and 'nextval' in description.default:
             if field_type == 'IntegerField':
                 return 'AutoField'
-            elif field_type == 'BigIntegerField':
+            if field_type == 'BigIntegerField':
                 return 'BigAutoField'
         return field_type
 

django/db/backends/postgresql/schema.py

@@ -50 +50 @@
                 return None
             if db_type.startswith('varchar'):
                 return self._create_index_sql(model, [field], suffix='_like', sql=self.sql_create_varchar_index)
-            elif db_type.startswith('text'):
+            if db_type.startswith('text'):
                 return self._create_index_sql(model, [field], suffix='_like', sql=self.sql_create_text_index)
         return None
 

django/db/backends/sqlite3/base.py

@@ -317 +317 @@
         return None
     if lookup_type == 'week_day':
         return (dt.isoweekday() % 7) + 1
-    elif lookup_type == 'week':
+    if lookup_type == 'week':
         return dt.isocalendar()[1]
-    elif lookup_type == 'quarter':
+    if lookup_type == 'quarter':
         return math.ceil(dt.month / 3)
-    else:
-        return getattr(dt, lookup_type)
+    return getattr(dt, lookup_type)
 
 
 def _sqlite_date_trunc(lookup_type, dt):
@@ -332 +331 @@
         return None
     if lookup_type == 'year':
         return "%i-01-01" % dt.year
-    elif lookup_type == 'quarter':
+    if lookup_type == 'quarter':
         month_in_quarter = dt.month - (dt.month - 1) % 3
         return '%i-%02i-01' % (dt.year, month_in_quarter)
-    elif lookup_type == 'month':
+    if lookup_type == 'month':
         return "%i-%02i-01" % (dt.year, dt.month)
-    elif lookup_type == 'day':
+    if lookup_type == 'day':
         return "%i-%02i-%02i" % (dt.year, dt.month, dt.day)
 
 
@@ -348 +347 @@
         return None
     if lookup_type == 'hour':
         return "%02i:00:00" % dt.hour
-    elif lookup_type == 'minute':
+    if lookup_type == 'minute':
         return "%02i:%02i:00" % (dt.hour, dt.minute)
-    elif lookup_type == 'second':
+    if lookup_type == 'second':
         return "%02i:%02i:%02i" % (dt.hour, dt.minute, dt.second)
 
 
@@ -386 +385 @@
         return None
     if lookup_type == 'week_day':
         return (dt.isoweekday() % 7) + 1
-    elif lookup_type == 'week':
+    if lookup_type == 'week':
         return dt.isocalendar()[1]
-    elif lookup_type == 'quarter':
+    if lookup_type == 'quarter':
         return math.ceil(dt.month / 3)
-    else:
-        return getattr(dt, lookup_type)
+    return getattr(dt, lookup_type)
 
 
 def _sqlite_datetime_trunc(lookup_type, dt, tzname):
@@ -400 +398 @@
         return None
     if lookup_type == 'year':
         return "%i-01-01 00:00:00" % dt.year
-    elif lookup_type == 'quarter':
+    if lookup_type == 'quarter':
         month_in_quarter = dt.month - (dt.month - 1) % 3
         return '%i-%02i-01 00:00:00' % (dt.year, month_in_quarter)
-    elif lookup_type == 'month':
+    if lookup_type == 'month':
         return "%i-%02i-01 00:00:00" % (dt.year, dt.month)
-    elif lookup_type == 'day':
+    if lookup_type == 'day':
         return "%i-%02i-%02i 00:00:00" % (dt.year, dt.month, dt.day)
-    elif lookup_type == 'hour':
+    if lookup_type == 'hour':
         return "%i-%02i-%02i %02i:00:00" % (dt.year, dt.month, dt.day, dt.hour)
-    elif lookup_type == 'minute':
+    if lookup_type == 'minute':
         return "%i-%02i-%02i %02i:%02i:00" % (dt.year, dt.month, dt.day, dt.hour, dt.minute)
-    elif lookup_type == 'second':
+    if lookup_type == 'second':
         return "%i-%02i-%02i %02i:%02i:%02i" % (dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second)
 
 

django/db/backends/sqlite3/operations.py

@@ -25 +25 @@
         """
         if len(fields) == 1:
             return 500
-        elif len(fields) > 1:
+        if fields:
             return self.connection.features.max_query_params // len(fields)
-        else:
-            return len(objs)
+        return len(objs)
 
     def check_expression_support(self, expression):
         bad_fields = (fields.DateField, fields.DateTimeField, fields.TimeField)

django/db/backends/sqlite3/schema.py

@@ -39 +39 @@
         # Manual emulation of SQLite parameter quoting
         if isinstance(value, bool):
             return str(int(value))
-        elif isinstance(value, (Decimal, float, int)):
+        if isinstance(value, (Decimal, float, int)):
             return str(value)
-        elif isinstance(value, str):
+        if isinstance(value, str):
             return "'%s'" % value.replace("\'", "\'\'")
-        elif value is None:
+        if value is None:
             return "NULL"
-        elif isinstance(value, (bytes, bytearray, memoryview)):
+        if isinstance(value, (bytes, bytearray, memoryview)):
             # Bytes are only allowed for BLOB fields, encoded as string
             # literals containing hexadecimal data and preceded by a single "X"
             # character.
             return "X'%s'" % value.hex()
-        else:
-            raise ValueError("Cannot quote parameter value %r of type %s" % (value, type(value)))
+        raise ValueError("Cannot quote parameter value %r of type %s" % (value, type(value)))
 
     def _remake_table(self, model, create_field=None, delete_field=None, alter_field=None):
         """

django/db/backends/utils.py

@@ -58 +58 @@
         with self.db.wrap_database_errors:
             if params is None and kparams is None:
                 return self.cursor.callproc(procname)
-            elif kparams is None:
+            if kparams is None:
                 return self.cursor.callproc(procname, params)
-            else:
-                params = params or ()
-                return self.cursor.callproc(procname, params, kparams)
+            params = params or ()
+            return self.cursor.callproc(procname, params, kparams)
 
     def execute(self, sql, params=None):
         return self._execute_with_wrappers(sql, params, many=False, executor=self._execute)

django/db/migrations/autodetector.py

@@ -55 +55 @@
         """
         if isinstance(obj, list):
             return [self.deep_deconstruct(value) for value in obj]
-        elif isinstance(obj, tuple):
+        if isinstance(obj, tuple):
             return tuple(self.deep_deconstruct(value) for value in obj)
-        elif isinstance(obj, dict):
+        if isinstance(obj, dict):
             return {
                 key: self.deep_deconstruct(value)
                 for key, value in obj.items()
             }
-        elif isinstance(obj, functools.partial):
+        if isinstance(obj, functools.partial):
             return (obj.func, self.deep_deconstruct(obj.args), self.deep_deconstruct(obj.keywords))
-        elif isinstance(obj, COMPILED_REGEX_TYPE):
+        if isinstance(obj, COMPILED_REGEX_TYPE):
             return RegexObject(obj)
-        elif isinstance(obj, type):
+        if isinstance(obj, type):
             # If this is a type that implements 'deconstruct' as an instance method,
             # avoid treating this as being deconstructible itself - see #22951
             return obj
-        elif hasattr(obj, 'deconstruct'):
+        if hasattr(obj, 'deconstruct'):
             deconstructed = obj.deconstruct()
             if isinstance(obj, models.Field):
                 # we have a field which also returns a name
@@ -84 +84 @@
                     for key, value in kwargs.items()
                 },
             )
-        else:
-            return obj
+        return obj
 
     def only_relation_agnostic_fields(self, fields):
         """
@@ -370 +369 @@
                 operation.name_lower == dependency[1].lower()
             )
         # Created field
-        elif dependency[2] is not None and dependency[3] is True:
+        if dependency[2] is not None and dependency[3] is True:
             return (
                 (
                     isinstance(operation, operations.CreateModel) and
@@ -384 +383 @@
                 )
             )
         # Removed field
-        elif dependency[2] is not None and dependency[3] is False:
+        if dependency[2] is not None and dependency[3] is False:
             return (
                 isinstance(operation, operations.RemoveField) and
                 operation.model_name_lower == dependency[1].lower() and
                 operation.name_lower == dependency[2].lower()
             )
         # Removed model
-        elif dependency[2] is None and dependency[3] is False:
+        if dependency[2] is None and dependency[3] is False:
             return (
                 isinstance(operation, operations.DeleteModel) and
                 operation.name_lower == dependency[1].lower()
             )
         # Field being altered
-        elif dependency[2] is not None and dependency[3] == "alter":
+        if dependency[2] is not None and dependency[3] == "alter":
             return (
                 isinstance(operation, operations.AlterField) and
                 operation.model_name_lower == dependency[1].lower() and
                 operation.name_lower == dependency[2].lower()
             )
         # order_with_respect_to being unset for a field
-        elif dependency[2] is not None and dependency[3] == "order_wrt_unset":
+        if dependency[2] is not None and dependency[3] == "order_wrt_unset":
             return (
                 isinstance(operation, operations.AlterOrderWithRespectTo) and
                 operation.name_lower == dependency[1].lower() and
                 (operation.order_with_respect_to or "").lower() != dependency[2].lower()
             )
         # Field is removed and part of an index/unique_together
-        elif dependency[2] is not None and dependency[3] == "foo_together_change":
+        if dependency[2] is not None and dependency[3] == "foo_together_change":
             return (
                 isinstance(operation, (operations.AlterUniqueTogether,
                                        operations.AlterIndexTogether)) and
                 operation.name_lower == dependency[1].lower()
             )
         # Unknown dependency. Raise an error.
-        else:
-            raise ValueError("Can't handle dependency %r" % (dependency, ))
+        raise ValueError("Can't handle dependency %r" % (dependency, ))
 
     def add_operation(self, app_label, operation, dependencies=None, beginning=False):
         # Dependencies are (app_label, model_name, field_name, create/delete as True/False)
@@ -1213 +1211 @@
         if len(ops) == 1:
             if isinstance(ops[0], operations.CreateModel):
                 return ops[0].name_lower
-            elif isinstance(ops[0], operations.DeleteModel):
+            if isinstance(ops[0], operations.DeleteModel):
                 return "delete_%s" % ops[0].name_lower
-            elif isinstance(ops[0], operations.AddField):
+            if isinstance(ops[0], operations.AddField):
                 return "%s_%s" % (ops[0].model_name_lower, ops[0].name_lower)
-            elif isinstance(ops[0], operations.RemoveField):
+            if isinstance(ops[0], operations.RemoveField):
                 return "remove_%s_%s" % (ops[0].model_name_lower, ops[0].name_lower)
         elif len(ops) > 1:
             if all(isinstance(o, operations.CreateModel) for o in ops):

django/db/migrations/loader.py

@@ -133 +133 @@
             raise AmbiguityError(
                 "There is more than one migration for '%s' with the prefix '%s'" % (app_label, name_prefix)
             )
-        elif len(results) == 0:
+        if len(results) == 0:
             raise KeyError("There no migrations for '%s' with the prefix '%s'" % (app_label, name_prefix))
-        else:
-            return self.disk_migrations[results[0]]
+        return self.disk_migrations[results[0]]
 
     def check_key(self, key, current_app):
         if (key[1] != "__first__" and key[1] != "__latest__") or key in self.graph:

django/db/migrations/operations/base.py

@@ -120 +120 @@
         """
         if self.elidable:
             return [operation]
-        elif operation.elidable:
+        if operation.elidable:
             return [self]
         return False
 

django/db/migrations/operations/fields.py

@@ -103 +103 @@
                         field=operation.field,
                     ),
                 ]
-            elif isinstance(operation, RemoveField):
+            if isinstance(operation, RemoveField):
                 return []
-            elif isinstance(operation, RenameField):
+            if isinstance(operation, RenameField):
                 return [
                     AddField(
                         model_name=self.model_name,
@@ -221 +221 @@
     def reduce(self, operation, in_between, app_label=None):
         if isinstance(operation, RemoveField) and self.is_same_field_operation(operation):
             return [operation]
-        elif isinstance(operation, RenameField) and self.is_same_field_operation(operation):
+        if isinstance(operation, RenameField) and self.is_same_field_operation(operation):
             return [
                 operation,
                 AlterField(

django/db/migrations/operations/models.py

@@ -128 +128 @@
         """
         if isinstance(model, str):
             return model.split(".", 1)
-        else:
-            return model._meta.app_label, model._meta.object_name
+        return model._meta.app_label, model._meta.object_name
 
     def reduce(self, operation, in_between, app_label=None):
         if (isinstance(operation, DeleteModel) and
                 self.name_lower == operation.name_lower and
                 not self.options.get("proxy", False)):
             return []
-        elif isinstance(operation, RenameModel) and self.name_lower == operation.old_name_lower:
+        if isinstance(operation, RenameModel) and self.name_lower == operation.old_name_lower:
             return [
                 CreateModel(
                     operation.new_name,
@@ -146 +145 @@
                     managers=self.managers,
                 ),
             ]
-        elif isinstance(operation, AlterModelOptions) and self.name_lower == operation.name_lower:
+        if isinstance(operation, AlterModelOptions) and self.name_lower == operation.name_lower:
             new_options = self.options.copy()
             new_options.update(operation.options)
             return [
@@ -158 +157 @@
                     managers=self.managers,
                 ),
             ]
-        elif isinstance(operation, FieldOperation) and self.name_lower == operation.model_name_lower:
+        if isinstance(operation, FieldOperation) and self.name_lower == operation.model_name_lower:
             if isinstance(operation, AddField):
                 # Don't allow optimizations of FKs through models they reference
                 if hasattr(operation.field, "remote_field") and operation.field.remote_field:
@@ -181 +180 @@
                         managers=self.managers,
                     ),
                 ]
-            elif isinstance(operation, AlterField):
+            if isinstance(operation, AlterField):
                 return [
                     CreateModel(
                         self.name,
@@ -194 +193 @@
                         managers=self.managers,
                     ),
                 ]
-            elif isinstance(operation, RemoveField):
+            if isinstance(operation, RemoveField):
                 return [
                     CreateModel(
                         self.name,
@@ -208 +207 @@
                         managers=self.managers,
                     ),
                 ]
-            elif isinstance(operation, RenameField):
+            if isinstance(operation, RenameField):
                 return [
                     CreateModel(
                         self.name,
@@ -284 +283 @@
     def _get_model_tuple(self, remote_model, app_label, model_name):
         if remote_model == RECURSIVE_RELATIONSHIP_CONSTANT:
             return app_label, model_name.lower()
-        elif '.' in remote_model:
+        if '.' in remote_model:
             return tuple(remote_model.lower().split('.'))
-        else:
-            return app_label, remote_model.lower()
+        return app_label, remote_model.lower()
 
     def state_forwards(self, app_label, state):
         # Add a new model.

django/db/migrations/state.py

@@ -21 +21 @@
     if isinstance(model, str):
         split = model.split('.', 1)
         return tuple(split) if len(split) == 2 else (app_label, split[0])
-    else:
-        return model._meta.app_label, model._meta.model_name
+    return model._meta.app_label, model._meta.model_name
 
 
 def _get_related_models(m):

django/db/models/base.py

@@ -1434 +1434 @@
                 )
             ]
 
-        elif any(not isinstance(fields, (tuple, list)) for fields in cls._meta.index_together):
+        if any(not isinstance(fields, (tuple, list)) for fields in cls._meta.index_together):
             return [
                 checks.Error(
                     "All 'index_together' elements must be lists or tuples.",
@@ -1443 +1443 @@
                 )
             ]
 
-        else:
-            errors = []
-            for fields in cls._meta.index_together:
-                errors.extend(cls._check_local_fields(fields, "index_together"))
-            return errors
+        errors = []
+        for fields in cls._meta.index_together:
+            errors.extend(cls._check_local_fields(fields, "index_together"))
+        return errors
 
     @classmethod
     def _check_unique_together(cls):
@@ -1461 +1460 @@
                 )
             ]
 
-        elif any(not isinstance(fields, (tuple, list)) for fields in cls._meta.unique_together):
+        if any(not isinstance(fields, (tuple, list)) for fields in cls._meta.unique_together):
             return [
                 checks.Error(
                     "All 'unique_together' elements must be lists or tuples.",
@@ -1470 +1469 @@
                 )
             ]
 
-        else:
-            errors = []
-            for fields in cls._meta.unique_together:
-                errors.extend(cls._check_local_fields(fields, "unique_together"))
-            return errors
+        errors = []
+        for fields in cls._meta.unique_together:
+            errors.extend(cls._check_local_fields(fields, "unique_together"))
+        return errors
 
     @classmethod
     def _check_local_fields(cls, fields, option):

django/db/models/expressions.py

@@ -307 +307 @@
         internal_type = field.get_internal_type()
         if internal_type == 'FloatField':
             return lambda value, expression, connection: None if value is None else float(value)
-        elif internal_type.endswith('IntegerField'):
+        if internal_type.endswith('IntegerField'):
             return lambda value, expression, connection: None if value is None else int(value)
-        elif internal_type == 'DecimalField':
+        if internal_type == 'DecimalField':
             return lambda value, expression, connection: None if value is None else Decimal(value)
         return self._convert_value_noop
 

django/db/models/fields/__init__.py

@@ -222 +222 @@
                     id='fields.E001',
                 )
             ]
-        elif LOOKUP_SEP in self.name:
+        if LOOKUP_SEP in self.name:
             return [
                 checks.Error(
                     'Field names must not contain "%s".' % (LOOKUP_SEP,),
@@ -230 +230 @@
                     id='fields.E002',
                 )
             ]
-        elif self.name == 'pk':
+        if self.name == 'pk':
             return [
                 checks.Error(
                     "'pk' is a reserved word that cannot be used as a field name.",
@@ -238 +238 @@
                     id='fields.E003',
                 )
             ]
-        else:
-            return []
+        return []
 
     def _check_choices(self):
         if self.choices:
@@ -251 +250 @@
                         id='fields.E004',
                     )
                 ]
-            elif any(isinstance(choice, str) or
+            if any(isinstance(choice, str) or
                      not is_iterable(choice) or len(choice) != 2
                      for choice in self.choices):
                 return [
@@ -262 +261 @@
                         id='fields.E005',
                     )
                 ]
-            else:
-                return []
-        else:
-            return []
+        return []
 
     def _check_db_index(self):
         if self.db_index not in (None, True, False):
@@ -276 +272 @@
                     id='fields.E006',
                 )
             ]
-        else:
-            return []
+        return []
 
     def _check_null_allowed_for_primary_keys(self):
         if (self.primary_key and self.null and
@@ -294 +289 @@
                     id='fields.E007',
                 )
             ]
-        else:
-            return []
+        return []
 
     def _check_backend_specific_checks(self, **kwargs):
         app_label = self.model._meta.app_label
@@ -337 +331 @@
                     id=self.system_check_removed_details.get('id', 'fields.EXXX'),
                 )
             ]
-        elif self.system_check_deprecated_details is not None:
+        if self.system_check_deprecated_details is not None:
             return [
                 checks.Warning(
                     self.system_check_deprecated_details.get(
@@ -1051 +1045 @@
                     id='fields.E120',
                 )
             ]
-        elif (not isinstance(self.max_length, int) or isinstance(self.max_length, bool) or
+        if (not isinstance(self.max_length, int) or isinstance(self.max_length, bool) or
                 self.max_length <= 0):
             return [
                 checks.Error(
@@ -1060 +1054 @@
                     id='fields.E121',
                 )
             ]
-        else:
-            return []
+        return []
 
     def cast_db_type(self, connection):
         if self.max_length is None:
@@ -1344 +1337 @@
 
     def to_python(self, value):
         if value is None:
-            return value
+            return None
         if isinstance(value, datetime.datetime):
             return value
         if isinstance(value, datetime.date):

django/db/models/fields/related.py

@@ -357 +357 @@
         base_q = Q(**base_filter)
         if isinstance(descriptor_filter, dict):
             return base_q & Q(**descriptor_filter)
-        elif descriptor_filter:
+        if descriptor_filter:
             return base_q & descriptor_filter
         return base_q
 
@@ -832 +832 @@
                     id='fields.E320',
                 )
             ]
-        elif on_delete == SET_DEFAULT and not self.has_default():
+        if on_delete == SET_DEFAULT and not self.has_default():
             return [
                 checks.Error(
                     'Field specifies on_delete=SET_DEFAULT, but has no default value.',
@@ -841 +841 @@
                     id='fields.E321',
                 )
             ]
-        else:
-            return []
+        return []
 
     def _check_unique(self, **kwargs):
         return [
@@ -1500 +1499 @@
         """
         if self.remote_field.through is not None:
             return self.remote_field.through._meta.db_table
-        elif self.db_table:
+        if self.db_table:
             return self.db_table
-        else:
-            m2m_table_name = '%s_%s' % (utils.strip_quotes(opts.db_table), self.name)
-            return utils.truncate_name(m2m_table_name, connection.ops.max_name_length())
+        m2m_table_name = '%s_%s' % (utils.strip_quotes(opts.db_table), self.name)
+        return utils.truncate_name(m2m_table_name, connection.ops.max_name_length())
 
     def _get_m2m_attr(self, related, attr):
         """

django/db/models/functions/datetime.py

@@ -198 +198 @@
             raise ValueError("Cannot truncate DateField '%s' to %s. " % (
                 field.name, output_field.__class__.__name__ if has_explicit_output_field else 'DateTimeField'
             ))
-        elif isinstance(field, TimeField) and (
+        if isinstance(field, TimeField) and (
                 isinstance(output_field, DateTimeField) or copy.kind in ('year', 'quarter', 'month', 'day', 'date')):
             raise ValueError("Cannot truncate TimeField '%s' to %s. " % (
                 field.name, output_field.__class__.__name__ if has_explicit_output_field else 'DateTimeField'

django/db/models/query.py

@@ -1102 +1102 @@
         """
         if self.query.extra_order_by or self.query.order_by:
             return True
-        elif self.query.default_ordering and self.query.get_meta().ordering:
+        if self.query.default_ordering and self.query.get_meta().ordering:
             return True
-        else:
-            return False
+        return False
 
     @property
     def db(self):

django/db/models/query_utils.py

@@ -67 +67 @@
         if not other:
             return copy.deepcopy(self)
         # Or if this Q is empty, ignore it and just use `other`.
-        elif not self:
+        if not self:
             return copy.deepcopy(other)
 
         obj = type(self)()

django/db/models/sql/compiler.py

@@ -499 +499 @@
                     # possible deadlock.
                     if nowait and not self.connection.features.has_select_for_update_nowait:
                         raise NotSupportedError('NOWAIT is not supported on this database backend.')
-                    elif skip_locked and not self.connection.features.has_select_for_update_skip_locked:
+                    if skip_locked and not self.connection.features.has_select_for_update_skip_locked:
                         raise NotSupportedError('SKIP LOCKED is not supported on this database backend.')
-                    elif of and not self.connection.features.has_select_for_update_of:
+                    if of and not self.connection.features.has_select_for_update_of:
                         raise NotSupportedError('FOR UPDATE OF is not supported on this database backend.')
                     for_update_part = self.connection.ops.for_update_sql(
                         nowait=nowait,
@@ -1161 +1161 @@
                 raise FieldError("Aggregate functions are not allowed in this query")
             if value.contains_over_clause:
                 raise FieldError('Window expressions are not allowed in this query.')
-        else:
-            value = field.get_db_prep_save(value, connection=self.connection)
-        return value
+            return value
+        return field.get_db_prep_save(value, connection=self.connection)
 
     def pre_save_val(self, field, obj):
         """

django/db/models/sql/query.py

@@ -1940 +1940 @@
         """
         if self._annotation_select_cache is not None:
             return self._annotation_select_cache
-        elif not self._annotations:
+        if not self._annotations:
             return {}
-        elif self.annotation_select_mask is not None:
+        if self.annotation_select_mask is not None:
             self._annotation_select_cache = OrderedDict(
                 (k, v) for k, v in self.annotations.items()
                 if k in self.annotation_select_mask
             )
             return self._annotation_select_cache
-        else:
-            return self.annotations
+        return self.annotations
 
     @property
     def extra_select(self):
@@ -1957 +1956 @@
             return self._extra_select_cache
         if not self._extra:
             return {}
-        elif self.extra_select_mask is not None:
+        if self.extra_select_mask is not None:
             self._extra_select_cache = OrderedDict(
                 (k, v) for k, v in self.extra.items()
                 if k in self.extra_select_mask
             )
             return self._extra_select_cache
-        else:
-            return self.extra
+        return self.extra
 
     def trim_start(self, names_with_path):
         """

django/db/models/sql/where.py

@@ -93 +93 @@
             if empty_needed == 0:
                 if self.negated:
                     return '', []
-                else:
-                    raise EmptyResultSet
+                raise EmptyResultSet
             if full_needed == 0:
                 if self.negated:
                     raise EmptyResultSet
-                else:
-                    return '', []
+                return '', []
         conn = ' %s ' % self.connector
         sql_string = conn.join(result)
         if sql_string:

django/forms/boundfield.py

@@ -193 +193 @@
         auto_id = self.form.auto_id  # Boolean or string
         if auto_id and '%s' in str(auto_id):
             return auto_id % self.html_name
-        elif auto_id:
+        if auto_id:
             return self.html_name
         return ''
 

django/forms/fields.py

@@ -739 +739 @@
         """
         if value in (True, 'True', 'true', '1'):
             return True
-        elif value in (False, 'False', 'false', '0'):
+        if value in (False, 'False', 'false', '0'):
             return False
-        else:
-            return None
+        return None
 
     def validate(self, value):
         pass
@@ -856 +855 @@
     def to_python(self, value):
         if not value:
             return []
-        elif not isinstance(value, (list, tuple)):
+        if not isinstance(value, (list, tuple)):
             raise ValidationError(self.error_messages['invalid_list'], code='invalid_list')
         return [str(val) for val in value]
 
@@ -1005 +1004 @@
             if not value or not [v for v in value if v not in self.empty_values]:
                 if self.required:
                     raise ValidationError(self.error_messages['required'], code='required')
-                else:
-                    return self.compress([])
+                return self.compress([])
         else:
             raise ValidationError(self.error_messages['invalid'], code='invalid')
         for i, field in enumerate(self.fields):

django/forms/models.py

@@ -1281 +1281 @@
         value = self.prepare_value(value)
         if self.required and not value:
             raise ValidationError(self.error_messages['required'], code='required')
-        elif not self.required and not value:
+        if not self.required and not value:
             return self.queryset.none()
         if not isinstance(value, (list, tuple)):
             raise ValidationError(self.error_messages['list'], code='list')

django/middleware/csrf.py

@@ -106 +106 @@
     # Allow only ASCII alphanumerics
     if re.search('[^a-zA-Z0-9]', token):
         return _get_new_csrf_token()
-    elif len(token) == CSRF_TOKEN_LENGTH:
+    if len(token) == CSRF_TOKEN_LENGTH:
         return token
-    elif len(token) == CSRF_SECRET_LENGTH:
+    if len(token) == CSRF_SECRET_LENGTH:
         # Older Django versions set cookies to values of CSRF_SECRET_LENGTH
         # alphanumeric characters. For backwards compatibility, accept
         # such values as unsalted secrets.

django/template/base.py

@@ -806 +806 @@
             msgid = mark_safe(msgid) if is_safe else msgid
             if self.message_context:
                 return pgettext_lazy(self.message_context, msgid)
-            else:
-                return gettext_lazy(msgid)
+            return gettext_lazy(msgid)
         return value
 
     def __repr__(self):

django/template/defaulttags.py

@@ -241 +241 @@
             state_frame[self] = compare_to
             # render true block if not already rendered
             return nodelist_true_output or self.nodelist_true.render(context)
-        elif self.nodelist_false:
+        if self.nodelist_false:
             return self.nodelist_false.render(context)
         return ''
 

django/template/loader.py

@@ -45 +45 @@
 
     if template_name_list:
         raise TemplateDoesNotExist(', '.join(template_name_list), chain=chain)
-    else:
-        raise TemplateDoesNotExist("No template names provided")
+    raise TemplateDoesNotExist("No template names provided")
 
 
 def render_to_string(template_name, context=None, request=None, using=None):

django/template/loaders/cached.py

@@ -47 +47 @@
         if cached:
             if isinstance(cached, type) and issubclass(cached, TemplateDoesNotExist):
                 raise cached(template_name)
-            elif isinstance(cached, TemplateDoesNotExist):
+            if isinstance(cached, TemplateDoesNotExist):
                 raise copy_exception(cached)
             return cached
 
@@ -56 +56 @@
         except TemplateDoesNotExist as e:
             self.get_template_cache[key] = copy_exception(e) if self.engine.debug else TemplateDoesNotExist
             raise
-        else:
-            self.get_template_cache[key] = template
+        self.get_template_cache[key] = template
 
         return template
 

django/template/response.py

@@ -61 +61 @@
         """Accept a template object, path-to-template, or list of paths."""
         if isinstance(template, (list, tuple)):
             return select_template(template, using=self.using)
-        elif isinstance(template, str):
+        if isinstance(template, str):
             return get_template(template, using=self.using)
-        else:
-            return template
+        return template
 
     def resolve_context(self, context):
         return context

django/test/utils.py

@@ -66 +66 @@
                 if key in subcontext:
                     return subcontext[key]
             raise KeyError(key)
-        else:
-            return super().__getitem__(key)
+        return super().__getitem__(key)
 
     def get(self, key, default=None):
         try:
@@ -374 +373 @@
     def __call__(self, decorated):
         if isinstance(decorated, type):
             return self.decorate_class(decorated)
-        elif callable(decorated):
+        if callable(decorated):
             return self.decorate_callable(decorated)
         raise TypeError('Cannot decorate object of type %s' % type(decorated))
 

django/utils/archive.py

@@ -112 +112 @@
         path = path.lstrip('/').lstrip('\\')
         if '/' in path and (('\\' in path and path.find('/') < path.find('\\')) or '\\' not in path):
             return path.split('/', 1)
-        elif '\\' in path:
+        if '\\' in path:
             return path.split('\\', 1)
-        else:
-            return path, ''
+        return path, ''
 
     def has_leading_dir(self, paths):
         """
@@ -127 +126 @@
             prefix, rest = self.split_leading_dir(path)
             if not prefix:
                 return False
-            elif common_prefix is None:
+            if common_prefix is None:
                 common_prefix = prefix
             elif prefix != common_prefix:
                 return False

django/utils/datastructures.py

@@ -236 +236 @@
     def complain(self, *wargs, **kwargs):
         if isinstance(self.warning, Exception):
             raise self.warning
-        else:
-            raise AttributeError(self.warning)
+        raise AttributeError(self.warning)
 
     # All list mutation functions complain.
     __delitem__ = complain

django/utils/formats.py

@@ -193 +193 @@
     """
     if isinstance(value, str):  # Handle strings first for performance reasons.
         return value
-    elif isinstance(value, bool):  # Make sure booleans don't get treated as numbers
+    if isinstance(value, bool):  # Make sure booleans don't get treated as numbers
         return str(value)
-    elif isinstance(value, (decimal.Decimal, float, int)):
+    if isinstance(value, (decimal.Decimal, float, int)):
         return number_format(value, use_l10n=use_l10n)
-    elif isinstance(value, datetime.datetime):
+    if isinstance(value, datetime.datetime):
         return date_format(value, 'DATETIME_FORMAT', use_l10n=use_l10n)
-    elif isinstance(value, datetime.date):
+    if isinstance(value, datetime.date):
         return date_format(value, use_l10n=use_l10n)
-    elif isinstance(value, datetime.time):
+    if isinstance(value, datetime.time):
         return time_format(value, 'TIME_FORMAT', use_l10n=use_l10n)
     return value
 
@@ -213 +213 @@
     """
     if isinstance(value, str):  # Handle strings first for performance reasons.
         return value
-    elif isinstance(value, bool):  # Don't treat booleans as numbers.
+    if isinstance(value, bool):  # Don't treat booleans as numbers.
         return str(value)
-    elif isinstance(value, (decimal.Decimal, float, int)):
+    if isinstance(value, (decimal.Decimal, float, int)):
         return number_format(value)
-    elif isinstance(value, datetime.datetime):
+    if isinstance(value, datetime.datetime):
         value = datetime_safe.new_datetime(value)
         format = default or get_format('DATETIME_INPUT_FORMATS')[0]
         return value.strftime(format)
-    elif isinstance(value, datetime.date):
+    if isinstance(value, datetime.date):
         value = datetime_safe.new_date(value)
         format = default or get_format('DATE_INPUT_FORMATS')[0]
         return value.strftime(format)
-    elif isinstance(value, datetime.time):
+    if isinstance(value, datetime.time):
         format = default or get_format('TIME_INPUT_FORMATS')[0]
         return value.strftime(format)
     return value

django/utils/functional.py

@@ -121 +121 @@
         def __cast(self):
             if self._delegate_bytes:
                 return self.__bytes_cast()
-            elif self._delegate_text:
+            if self._delegate_text:
                 return self.__text_cast()
-            else:
-                return func(*self.__args, **self.__kw)
+            return func(*self.__args, **self.__kw)
 
         def __str__(self):
             # object defines __str__(), so __prepare_class__() won't overload

django/utils/ipv6.py

@@ -29 +29 @@
 
     if unpack_ipv4 and addr.ipv4_mapped:
         return str(addr.ipv4_mapped)
-    elif addr.ipv4_mapped:
+    if addr.ipv4_mapped:
         return '::ffff:%s' % str(addr.ipv4_mapped)
 
     return str(addr)

django/utils/safestring.py

@@ -34 +34 @@
         t = super().__add__(rhs)
         if isinstance(rhs, SafeText):
             return SafeText(t)
-        elif isinstance(rhs, SafeBytes):
+        if isinstance(rhs, SafeBytes):
             return SafeBytes(t)
         return t
 

django/views/generic/dates.py

@@ -109 +109 @@
                 return date.replace(year=date.year + 1, month=1, day=1)
             except ValueError:
                 raise Http404(_("Date out of range"))
-        else:
-            return date.replace(month=date.month + 1, day=1)
+        return date.replace(month=date.month + 1, day=1)
 
     def _get_current_month(self, date):
         """Return the start date of the previous interval."""

django/views/generic/detail.py

@@ -82 +82 @@
         """Get the name to use for the object."""
         if self.context_object_name:
             return self.context_object_name
-        elif isinstance(obj, models.Model):
+        if isinstance(obj, models.Model):
             return obj._meta.model_name
-        else:
-            return None
+        return None
 
     def get_context_data(self, **kwargs):
         """Insert the single object into the context dict."""

django/views/generic/list.py

@@ -105 +105 @@
         """Get the name of the item to be used in the context."""
         if self.context_object_name:
             return self.context_object_name
-        elif hasattr(object_list, 'model'):
+        if hasattr(object_list, 'model'):
             return '%s_list' % object_list.model._meta.model_name
-        else:
-            return None
+        return None
 
     def get_context_data(self, *, object_list=None, **kwargs):
         """Get the context for this view."""

scripts/manage_translations.py

@@ -63 +63 @@
     """ Return the Transifex resource name """
     if name == 'core':
         return "django.core"
-    else:
-        return "django.contrib-%s" % name
+    return "django.contrib-%s" % name
 
 
 def _check_diff(cat_name, base_path):

tests/admin_filters/tests.py

@@ -51 +51 @@
     def queryset(self, request, queryset):
         if self.value() == 'the 90s':
             return queryset.filter(year__gte=1990, year__lte=1999)
-        else:
-            return queryset.exclude(year__gte=1990, year__lte=1999)
+        return queryset.exclude(year__gte=1990, year__lte=1999)
 
 
 class DecadeListFilterWithTitleAndParameter(DecadeListFilter):
@@ -127 +126 @@
     def lookups(self, request, model_admin):
         if self.value() == 'the 80s':
             return (('the 90s', "the 1990's"),)
-        elif self.value() == 'the 90s':
+        if self.value() == 'the 90s':
             return (('the 80s', "the 1980's"),)
-        else:
-            return (('the 80s', "the 1980's"), ('the 90s', "the 1990's"),)
+        return (('the 80s', "the 1980's"), ('the 90s', "the 1990's"),)
 
 
 class CustomUserAdmin(UserAdmin):

tests/admin_ordering/models.py

@@ -35 +35 @@
     def get_ordering(self, request):
         if request.user.is_superuser:
             return ['rank']
-        else:
-            return ['name']
+        return ['name']

tests/admin_views/admin.py

@@ -450 +450 @@
     def coolness(self, instance):
         if instance.pk:
             return "%d amount of cool." % instance.pk
-        else:
-            return "Unknown coolness."
+        return "Unknown coolness."
 
     def value(self, instance):
         return 1000

tests/auth_tests/test_auth_backends.py

@@ -332 +332 @@
         if isinstance(obj, TestObj):
             if user.username == 'test2':
                 return True
-            elif user.is_anonymous and perm == 'anon':
+            if user.is_anonymous and perm == 'anon':
                 return True
-            elif not user.is_active and perm == 'inactive':
+            if not user.is_active and perm == 'inactive':
                 return True
         return False
 
@@ -354 +354 @@
             return ['anon']
         if user.username == 'test2':
             return ['simple', 'advanced']
-        else:
-            return ['simple']
+        return ['simple']
 
     def get_group_permissions(self, user, obj=None):
         if not obj:
@@ -366 +365 @@
 
         if 'test_group' in [group.name for group in user.groups.all()]:
             return ['group_perm']
-        else:
-            return ['none']
+        return ['none']
 
 
 @modify_settings(AUTHENTICATION_BACKENDS={

tests/builtin_server/tests.py

@@ -20 +20 @@
         if not self.status:
             raise AssertionError("write() before start_response()")
 
-        elif not self.headers_sent:
+        if not self.headers_sent:
             # Before the first output, send the stored headers
             self.bytes_sent = len(data)    # make sure we know content-length
             self.send_headers()

tests/contenttypes_tests/operations_migrations/0002_rename_foo.py

@@ -10 +10 @@
     else:
         if not ContentType.objects.filter(app_label='contenttypes_tests', model='foo').exists():
             raise AssertionError('The contenttypes_tests.Foo ContentType should not be cached.')
-        elif content_type.model != 'foo':
+        if content_type.model != 'foo':
             raise AssertionError(
                 "The cached contenttypes_tests.Foo ContentType should have "
                 "its model set to 'foo'."

tests/file_uploads/views.py

@@ -22 +22 @@
         if os.path.dirname(form_data['file_field'].name) != '':
             return HttpResponseServerError()
         return HttpResponse('')
-    else:
-        return HttpResponseServerError()
+    return HttpResponseServerError()
 
 
 def file_upload_view_verify(request):
@@ -77 +76 @@
     obj.delete()
     os.unlink(full_name)
 
-    if response:
-        return response
-    else:
-        return HttpResponse('')
+    return response or HttpResponse('')
 
 
 def file_upload_echo(request):

tests/forms_tests/field_tests/test_filepathfield.py

@@ -11 +11 @@
         if x.startswith(PATH):
             x = x[len(PATH):]
         return x.replace('\\', '/')
-    elif isinstance(x, tuple):
+    if isinstance(x, tuple):
         return tuple(fix_os_paths(list(x)))
-    elif isinstance(x, list):
+    if isinstance(x, list):
         return [fix_os_paths(y) for y in x]
-    else:
-        return x
+    return x
 
 
 class FilePathFieldTest(SimpleTestCase):

tests/gis_tests/tests.py

@@ -26 +26 @@
             if func == 'postgis_lib_version':
                 if self.version is None:
                     raise ProgrammingError
-                else:
-                    return self.version
+                return self.version
             elif func == 'version':
                 pass
             else:

tests/gis_tests/utils.py

@@ -31 +31 @@
         def inner():
             pass
         return inner
-    else:
-        return test_func
+    return test_func
 
 
 # Decorators to disable entire test functions for specific

tests/humanize_tests/tests.py

@@ -277 +277 @@
             def now(cls, tz=None):
                 if tz is None or tz.utcoffset(documented_now) is None:
                     return documented_now
-                else:
-                    return documented_now.replace(tzinfo=tz) + tz.utcoffset(now)
+                return documented_now.replace(tzinfo=tz) + tz.utcoffset(now)
 
         orig_humanize_datetime = humanize.datetime
         humanize.datetime = DocumentedMockDateTime

tests/i18n/test_extraction.py

@@ -79 +79 @@
         pattern = re.compile(r'^\#\:.*' + re.escape(needle), re.MULTILINE)
         if assert_presence:
             return self.assertRegex(po_contents, pattern, '"%s" not found in final .po file.' % needle)
-        else:
-            return self.assertNotRegex(po_contents, pattern, '"%s" shouldn\'t be in final .po file.' % needle)
+        return self.assertNotRegex(po_contents, pattern, '"%s" shouldn\'t be in final .po file.' % needle)
 
     def _get_token_line_number(self, path, token):
         with open(path) as f:

tests/introspection/tests.py

@@ -211 +211 @@
     dt = connection.introspection.get_field_type(dbtype, description)
     if type(dt) is tuple:
         return dt[0]
-    else:
-        return dt
+    return dt

tests/migrations/routers.py

@@ -9 +9 @@
         """
         if model_name == 'tribble':
             return db == 'other'
-        elif db == 'other':
+        if db == 'other':
             return False

tests/migrations/test_commands.py

@@ -698 +698 @@
         def patched_has_table(migration_recorder):
             if migration_recorder.connection is connections['other']:
                 raise Exception('Other connection')
-            else:
-                return mock.DEFAULT
+            return mock.DEFAULT
 
         self.assertTableNotExists('migrations_unicodemodel')
         apps.register_model('migrations', UnicodeModel)

tests/model_forms/models.py

@@ -377 +377 @@
     def clean(self):
         if self.name1 == 'FORBIDDEN_VALUE':
             raise ValidationError({'name1': [ValidationError('Model.clean() error messages.')]})
-        elif self.name1 == 'FORBIDDEN_VALUE2':
+        if self.name1 == 'FORBIDDEN_VALUE2':
             raise ValidationError({'name1': 'Model.clean() error messages (simpler syntax).'})
-        elif self.name1 == 'GLOBAL_ERROR':
+        if self.name1 == 'GLOBAL_ERROR':
             raise ValidationError("Global error message.")
 
 

tests/multiple_database/tests.py

@@ -1568 +1568 @@
     def allow_migrate(self, db, app_label, model_name=None, **hints):
         if db == 'other':
             return model_name == 'pet'
-        else:
-            return model_name != 'pet'
+        return model_name != 'pet'
 
 
 class FixtureTestCase(TestCase):

tests/runtests.py

@@ -236 +236 @@
         # This doesn't work before django.setup() on some databases.
         if all(conn.features.can_clone_databases for conn in connections.all()):
             return default_test_processes()
-        else:
-            return 1
-    else:
-        return parallel
+        return 1
+    return parallel
 
 
 class ActionSelenium(argparse.Action):

tests/servers/test_basehttp.py

@@ -101 +101 @@
         def makefile(mode, *a, **kw):
             if mode == 'rb':
                 return rfile
-            elif mode == 'wb':
+            if mode == 'wb':
                 return wfile
 
         request = Stub(makefile=makefile)

tests/template_tests/utils.py

@@ -115 +115 @@
     def __getitem__(self, key):
         if key == 'silent_fail_key':
             raise SomeException
-        elif key == 'noisy_fail_key':
+        if key == 'noisy_fail_key':
             raise SomeOtherException
         raise KeyError
 

tests/test_client/views.py

@@ -33 +33 @@
     """
     if request.method.upper() != "TRACE":
         return HttpResponseNotAllowed("TRACE")
-    elif request.body:
+    if request.body:
         return HttpResponseBadRequest("TRACE requests MUST NOT include an entity")
-    else:
-        protocol = request.META["SERVER_PROTOCOL"]
-        t = Template(
-            '{{ method }} {{ uri }} {{ version }}',
-            name="TRACE Template",
-        )
-        c = Context({
-            'method': request.method,
-            'uri': request.path,
-            'version': protocol,
-        })
-        return HttpResponse(t.render(c))
+    protocol = request.META["SERVER_PROTOCOL"]
+    t = Template(
+        '{{ method }} {{ uri }} {{ version }}',
+        name="TRACE Template",
+    )
+    c = Context({
+        'method': request.method,
+        'uri': request.path,
+        'version': protocol,
+    })
+    return HttpResponse(t.render(c))
 
 
 def post_view(request):

tests/test_client_regress/views.py

@@ -52 +52 @@
     """
     if name == 'Arthur Dent':
         return HttpResponse('Hi, Arthur')
-    else:
-        return HttpResponse('Howdy, %s' % name)
+    return HttpResponse('Howdy, %s' % name)
 
 
 def nested_view(request):

tests/utils_tests/test_lazyobject.py

@@ -376 +376 @@
         for attr in ['bar', 'baz', 'quux']:
             if hasattr(self, attr) != hasattr(other, attr):
                 return False
-            elif getattr(self, attr, None) != getattr(other, attr, None):
+            if getattr(self, attr, None) != getattr(other, attr, None):
                 return False
         return True