Fix pylint no-else-return error

misago/admin/middleware.py

@@ -16,5 +16,3 @@ class AdminAuthMiddleware(MiddlewareMixin):
                     return login(request)
                 return redirect("%s:index" % request.admin_namespace)
             auth.update_admin_session(request)
-
-        return None

misago/admin/views/__init__.py

@@ -15,7 +15,6 @@ def get_protected_namespace(request):
                 return namespace
         except NoReverseMatch:
             pass
-    return None
 
 
 def render(request, template, context=None, error_page=False):

misago/admin/views/generic/list.py

@@ -250,7 +250,6 @@ class ListView(AdminView):
         for order_by, _ in self.ordering:  # pylint: disable=not-an-iterable
             if order_by == new_ordering:
                 return order_by
-        return None
 
     def get_ordering_methods(self, request):
         return {

misago/categories/forms.py

@@ -29,8 +29,7 @@ class AdminCategoryFieldMixin:
         level = getattr(obj, obj._mptt_meta.level_attr) - self.base_level
         if level > 0:
             return mark_safe(conditional_escape(self.level_indicator) * level)
-        else:
-            return ""
+        return ""
 
 
 class AdminCategoryChoiceField(AdminCategoryFieldMixin, TreeNodeChoiceField):

misago/categories/permissions.py

@@ -19,8 +19,6 @@ class PermissionsForm(forms.Form):
 def change_permissions_form(role):
     if isinstance(role, CategoryRole):
         return PermissionsForm
-    else:
-        return None
 
 
 def build_acl(acl, roles, key_name):
@@ -51,7 +49,7 @@ def build_category_acl(acl, category, categories_roles, key_name):
         if category.parent_id not in acl["visible_categories"]:
             # dont bother with child categories of invisible parents
             return
-        elif not acl["categories"][category.parent_id]["can_browse"]:
+        if not acl["categories"][category.parent_id]["can_browse"]:
             # parent's visible, but its contents aint
             return
 

misago/categories/serializers.py

@@ -69,7 +69,6 @@ class CategorySerializer(serializers.ModelSerializer, MutableFields):
                 "plain": obj.description,
                 "html": format_plaintext_for_html(obj.description),
             }
-        return None
 
     def get_is_read(self, obj):
         try:
@@ -100,7 +99,6 @@ class CategorySerializer(serializers.ModelSerializer, MutableFields):
                     kwargs={"slug": obj.last_poster_slug, "pk": obj.last_poster_id},
                 ),
             }
-        return None
 
     def get_url(self, obj):
         return {

misago/categories/views/permsadmin.py

@@ -41,22 +41,22 @@ class RoleFormMixin:
                     valid_forms += 1
 
             form = CategoryRoleForm(request.POST, instance=target)
-            if form.is_valid() and len(perms_forms) == valid_forms:
-                new_permissions = {}
-                for permissions_form in perms_forms:
-                    cleaned_data = permissions_form.cleaned_data
-                    new_permissions[permissions_form.prefix] = cleaned_data
+            if form.is_valid():
+                if len(perms_forms) == valid_forms:
+                    new_permissions = {}
+                    for permissions_form in perms_forms:
+                        cleaned_data = permissions_form.cleaned_data
+                        new_permissions[permissions_form.prefix] = cleaned_data
 
-                form.instance.permissions = new_permissions
-                form.instance.save()
+                    form.instance.permissions = new_permissions
+                    form.instance.save()
 
-                messages.success(request, self.message_submit % {"name": target.name})
+                    messages.success(request, self.message_submit % {"name": target.name})
 
-                if "stay" in request.POST:
-                    return redirect(request.path)
-                else:
+                    if "stay" in request.POST:
+                        return redirect(request.path)
                     return redirect(self.root_link)
-            elif form.is_valid() and len(perms_forms) != valid_forms:
+
                 form.add_error(None, _("Form contains errors."))
 
         return self.render(
@@ -132,8 +132,7 @@ class CategoryPermissions(CategoryAdmin, generic.ModelFormView):
             messages.success(request, message % {"name": target.name})
             if "stay" in request.POST:
                 return redirect(request.path)
-            else:
-                return redirect(self.root_link)
+            return redirect(self.root_link)
 
         return self.render(request, {"forms": forms, "target": target})
 
@@ -200,8 +199,7 @@ class RoleCategoriesACL(RoleAdmin, generic.ModelFormView):
             messages.success(request, message % {"name": target.name})
             if "stay" in request.POST:
                 return redirect(request.path)
-            else:
-                return redirect(self.root_link)
+            return redirect(self.root_link)
 
         return self.render(request, {"forms": forms, "target": target})
 

misago/core/exceptionhandler.py

@@ -102,4 +102,3 @@ def handle_api_exception(exception, context):
             except IndexError:
                 pass
         return response
-    return None

misago/core/momentjs.py

@@ -8,8 +8,6 @@ def get_locale_url(language):
     if clean_language:
         return MOMENT_STATIC_PATH % clean_language
 
-    return None
-
 
 def clean_language_name(language):
     # lowercase language

misago/faker/management/commands/createfakebans.py

@@ -28,8 +28,7 @@ def fake_username_ban(fake):
 def fake_email_ban(fake):
     if random.randint(0, 100) < 35:
         return "*@%s" % fake.domain_name()
-    else:
-        return fake.email()
+    return fake.email()
 
 
 def fake_ip_ban(fake):
@@ -69,9 +68,9 @@ def fake_ip_ban(fake):
 def create_fake_test(fake, test_type):
     if test_type == Ban.USERNAME:
         return fake_username_ban(fake)
-    elif test_type == Ban.EMAIL:
+    if test_type == Ban.EMAIL:
         return fake_email_ban(fake)
-    elif test_type == Ban.IP:
+    if test_type == Ban.IP:
         return fake_ip_ban(fake)
 
 

misago/legal/utils.py

@@ -31,8 +31,6 @@ def get_required_user_agreement(user, agreements):
                 # possible stale cache
                 Agreement.invalidate_cache()
 
-    return None
-
 
 def get_parsed_agreement_text(request, agreement):
     if not agreement.text:
@@ -48,11 +46,11 @@ def get_parsed_agreement_text(request, agreement):
 
     if cached_content and cached_content.get("checksum") == unparsed_checksum:
         return cached_content["parsed"]
-    else:
-        parsed = common_flavour(request, None, unparsed_content)["parsed_text"]
-        cached_content = {"checksum": unparsed_checksum, "parsed": parsed}
-        cache.set(cache_name, cached_content)
-        return cached_content["parsed"]
+    
+    parsed = common_flavour(request, None, unparsed_content)["parsed_text"]
+    cached_content = {"checksum": unparsed_checksum, "parsed": parsed}
+    cache.set(cache_name, cached_content)
+    return cached_content["parsed"]
 
 
 def save_user_agreement_acceptance(user, agreement, commit=False):

misago/markup/bbcode/blocks.py

@@ -60,8 +60,7 @@ class QuotePreprocessor(Preprocessor):
 
         if title:
             return "\n\n%s%s\n\n%s\n\n%s\n\n" % (QUOTE_START, title, text, QUOTE_END)
-        else:
-            return "\n\n%s\n\n%s\n\n%s\n\n" % (QUOTE_START, text, QUOTE_END)
+        return "\n\n%s\n\n%s\n\n%s\n\n" % (QUOTE_START, text, QUOTE_END)
 
 
 class QuoteBlockProcessor(BlockProcessor):

misago/markup/mentions.py

@@ -57,9 +57,9 @@ def parse_string(request, element, mentions_dict):
         if mentions_dict[username]:
             user = mentions_dict[username]
             return '<a href="%s">@%s</a>' % (user.get_absolute_url(), user.username)
-        else:
-            # we've failed to resolve user for username
-            return matchobj.group(0)
+
+        # we've failed to resolve user for username
+        return matchobj.group(0)
 
     replaced_string = USERNAME_RE.sub(replace_mentions, element.string)
     element.replace_with(BeautifulSoup(replaced_string, "html.parser"))

misago/readtracker/dates.py

@@ -14,12 +14,10 @@ def get_cutoff_date(user=None):
 
 
 def is_date_tracked(date, user):
-    if date:
-        cutoff_date = get_cutoff_date()
-
-        if cutoff_date < user.joined_on:
-            cutoff_date = user.joined_on
-
-        return date > cutoff_date
-    else:
+    if not date:
         return False
+    
+    cutoff_date = get_cutoff_date()
+    if cutoff_date < user.joined_on:
+        cutoff_date = user.joined_on
+    return date > cutoff_date

misago/search/permissions.py

@@ -15,8 +15,6 @@ class PermissionsForm(forms.Form):
 def change_permissions_form(role):
     if isinstance(role, Role):
         return PermissionsForm
-    else:
-        return None
 
 
 def build_acl(acl, roles, key_name):

misago/threads/api/postendpoints/patch_event.py

@@ -11,8 +11,7 @@ def patch_acl(request, event, value):
     if value:
         add_acl_to_obj(request.user_acl, event)
         return {"acl": event.acl}
-    else:
-        return {"acl": None}
+    return {"acl": None}
 
 
 event_patch_dispatcher.add("acl", patch_acl)
@@ -43,4 +42,5 @@ def event_patch_endpoint(request, event):
 
         event.category.synchronize()
         event.category.save()
+
     return response

misago/threads/api/postendpoints/patch_post.py

@@ -27,8 +27,7 @@ def patch_acl(request, post, value):
     if value:
         add_acl_to_obj(request.user_acl, post)
         return {"acl": post.acl}
-    else:
-        return {"acl": None}
+    return {"acl": None}
 
 
 post_patch_dispatcher.add("acl", patch_acl)

misago/threads/api/postingendpoint/reply.py

@@ -11,9 +11,11 @@ from ...validators import validate_post, validate_post_length, validate_thread_t
 class ReplyMiddleware(PostingMiddleware):
     def get_serializer(self):
         if self.mode == PostingEndpoint.START:
-            return ThreadSerializer(data=self.request.data, context=self.kwargs)
+            serializer = ThreadSerializer
         else:
-            return ReplySerializer(data=self.request.data, context=self.kwargs)
+            serializer = ReplySerializer
+
+        return serializer(data=self.request.data, context=self.kwargs)
 
     def save(self, serializer):
         if self.mode == PostingEndpoint.START:
@@ -93,10 +95,10 @@ class ReplySerializer(serializers.Serializer):
     def parse_post(self, post):
         if self.context["mode"] == PostingEndpoint.START:
             return common_flavour(self.context["request"], self.context["user"], post)
-        else:
-            return common_flavour(
-                self.context["request"], self.context["post"].poster, post
-            )
+
+        return common_flavour(
+            self.context["request"], self.context["post"].poster, post
+        )
 
 
 class ThreadSerializer(ReplySerializer):

misago/threads/api/threadendpoints/delete.py

@@ -25,9 +25,9 @@ def delete_bulk(request, viewmodel):
             if "details" in errors:
                 return Response(hydrate_error_details(errors["details"]), status=400)
             return Response({"detail": errors[0]}, status=403)
-        else:
-            errors = list(serializer.errors)[0][0]
-            return Response({"detail": errors}, status=400)
+
+        errors = list(serializer.errors)[0][0]
+        return Response({"detail": errors}, status=400)
 
     for thread in serializer.validated_data["threads"]:
         with transaction.atomic():

misago/threads/api/threadendpoints/list.py

@@ -43,8 +43,7 @@ class ForumThreadsList(ThreadsList):
     def get_category(self, request, pk=None):
         if pk:
             return ThreadsCategory(request, pk=pk)
-        else:
-            return ThreadsRootCategory(request)
+        return ThreadsRootCategory(request)
 
 
 class PrivateThreadsList(ThreadsList):

misago/threads/api/threadendpoints/merge.py

@@ -95,11 +95,10 @@ def threads_merge_endpoint(request):
         if "threads" in serializer.errors:
             errors = {"detail": serializer.errors["threads"][0]}
             return Response(errors, status=403)
-        elif "non_field_errors" in serializer.errors:
+        if "non_field_errors" in serializer.errors:
             errors = {"detail": serializer.errors["non_field_errors"][0]}
             return Response(errors, status=403)
-        else:
-            return Response(serializer.errors, status=400)
+        return Response(serializer.errors, status=400)
 
     threads = serializer.validated_data["threads"]
     invalid_threads = []

misago/threads/api/threadendpoints/patch.py

@@ -54,8 +54,7 @@ def patch_acl(request, thread, value):
     if value:
         add_acl_to_obj(request.user_acl, thread)
         return {"acl": thread.acl}
-    else:
-        return {"acl": None}
+    return {"acl": None}
 
 
 thread_patch_dispatcher.add("acl", patch_acl)
@@ -204,7 +203,8 @@ def patch_subscription(request, thread, value):
         )
 
         return {"subscription": False}
-    elif value == "email":
+
+    if value == "email":
         thread.subscription = request.user.subscription_set.create(
             thread=thread,
             category=thread.category,
@@ -213,8 +213,8 @@ def patch_subscription(request, thread, value):
         )
 
         return {"subscription": True}
-    else:
-        return {"subscription": None}
+
+    return {"subscription": None}
 
 
 thread_patch_dispatcher.replace("subscription", patch_subscription)
@@ -337,11 +337,11 @@ def patch_remove_participant(request, thread, value):
 
     if len(thread.participants_list) == 1:
         return {"deleted": True}
-    else:
-        make_participants_aware(request.user, thread)
-        participants = ThreadParticipantSerializer(thread.participants_list, many=True)
 
-        return {"deleted": False, "participants": participants.data}
+    make_participants_aware(request.user, thread)
+    participants = ThreadParticipantSerializer(thread.participants_list, many=True)
+
+    return {"deleted": False, "participants": participants.data}
 
 
 thread_patch_dispatcher.remove("participants", patch_remove_participant)

misago/threads/api/threadpoll.py

@@ -120,8 +120,7 @@ class ViewSet(viewsets.ViewSet):
     def votes(self, request, thread_pk, pk=None):
         if request.method == "POST":
             return self.post_votes(request, thread_pk, pk)
-        else:
-            return self.get_votes(request, thread_pk, pk)
+        return self.get_votes(request, thread_pk, pk)
 
     @transaction.atomic
     def post_votes(self, request, thread_pk, pk=None):

misago/threads/api/threadposts.py

@@ -95,21 +95,21 @@ class ViewSet(viewsets.ViewSet):
             request, PostingEndpoint.REPLY, thread=thread, post=post
         )
 
-        if posting.is_valid():
-            user_posts = request.user.posts
+        if not posting.is_valid():
+            return Response(posting.errors, status=400)
 
-            posting.save()
+        user_posts = request.user.posts
 
-            # setup extra data for serialization
-            post.is_read = False
-            post.is_new = True
-            post.poster.posts = user_posts + 1
+        posting.save()
 
-            make_users_status_aware(request, [post.poster])
+        # setup extra data for serialization
+        post.is_read = False
+        post.is_new = True
+        post.poster.posts = user_posts + 1
 
-            return Response(PostSerializer(post, context={"user": request.user}).data)
-        else:
-            return Response(posting.errors, status=400)
+        make_users_status_aware(request, [post.poster])
+
+        return Response(PostSerializer(post, context={"user": request.user}).data)
 
     @transaction.atomic
     def update(self, request, thread_pk, pk=None):
@@ -122,21 +122,21 @@ class ViewSet(viewsets.ViewSet):
             request, PostingEndpoint.EDIT, thread=thread, post=post
         )
 
-        if posting.is_valid():
-            post_edits = post.edits
+        if not posting.is_valid():
+            return Response(posting.errors, status=400)
 
-            posting.save()
+        post_edits = post.edits
 
-            post.is_read = True
-            post.is_new = False
-            post.edits = post_edits + 1
+        posting.save()
 
-            if post.poster:
-                make_users_status_aware(request, [post.poster])
+        post.is_read = True
+        post.is_new = False
+        post.edits = post_edits + 1
 
-            return Response(PostSerializer(post, context={"user": request.user}).data)
-        else:
-            return Response(posting.errors, status=400)
+        if post.poster:
+            make_users_status_aware(request, [post.poster])
+
+        return Response(PostSerializer(post, context={"user": request.user}).data)
 
     def patch(self, request, thread_pk):
         thread = self.get_thread(request, thread_pk)
@@ -149,8 +149,7 @@ class ViewSet(viewsets.ViewSet):
 
         if post.is_event:
             return event_patch_endpoint(request, post)
-        else:
-            return post_patch_endpoint(request, post)
+        return post_patch_endpoint(request, post)
 
     @transaction.atomic
     def delete(self, request, thread_pk, pk=None):
@@ -165,9 +164,7 @@ class ViewSet(viewsets.ViewSet):
     @detail_route(methods=["post"])
     def read(self, request, thread_pk, pk=None):
         thread = self.get_thread(request, thread_pk, subscription_aware=True).unwrap()
-
         post = self.get_post(request, thread, pk).unwrap()
-
         return post_read_endpoint(request, thread, post)
 
     @detail_route(methods=["get"], url_path="editor")
@@ -202,25 +199,25 @@ class ViewSet(viewsets.ViewSet):
         thread = self.get_thread(request, thread_pk).unwrap()
         allow_reply_thread(request.user_acl, thread)
 
-        if "reply" in request.query_params:
-            reply_to = self.get_post(
-                request, thread, request.query_params["reply"]
-            ).unwrap()
-
-            if reply_to.is_event:
-                raise PermissionDenied(_("You can't reply to events."))
-            if reply_to.is_hidden and not reply_to.acl["can_see_hidden"]:
-                raise PermissionDenied(_("You can't reply to hidden posts."))
-
-            return Response(
-                {
-                    "id": reply_to.pk,
-                    "post": reply_to.original,
-                    "poster": reply_to.poster_name,
-                }
-            )
-        else:
+        if "reply" not in request.query_params:
             return Response({})
+        
+        reply_to = self.get_post(
+            request, thread, request.query_params["reply"]
+        ).unwrap()
+
+        if reply_to.is_event:
+            raise PermissionDenied(_("You can't reply to events."))
+        if reply_to.is_hidden and not reply_to.acl["can_see_hidden"]:
+            raise PermissionDenied(_("You can't reply to hidden posts."))
+
+        return Response(
+            {
+                "id": reply_to.pk,
+                "post": reply_to.original,
+                "poster": reply_to.poster_name,
+            }
+        )
 
     @detail_route(methods=["get", "post"])
     def edits(self, request, thread_pk, pk=None):

misago/threads/api/threads.py

@@ -81,19 +81,19 @@ class ThreadViewSet(ViewSet):
             post=post,
         )
 
-        if posting.is_valid():
-            posting.save()
-
-            return Response(
-                {
-                    "id": thread.pk,
-                    "title": thread.title,
-                    "url": thread.get_absolute_url(),
-                }
-            )
-        else:
+        if not posting.is_valid():
             return Response(posting.errors, status=400)
 
+        posting.save()
+
+        return Response(
+            {
+                "id": thread.pk,
+                "title": thread.title,
+                "url": thread.get_absolute_url(),
+            }
+        )
+
     @detail_route(methods=["post"], url_path="merge")
     @transaction.atomic
     def thread_merge(self, request, pk=None):
@@ -138,15 +138,15 @@ class PrivateThreadViewSet(ViewSet):
             post=post,
         )
 
-        if posting.is_valid():
-            posting.save()
-
-            return Response(
-                {
-                    "id": thread.pk,
-                    "title": thread.title,
-                    "url": thread.get_absolute_url(),
-                }
-            )
-        else:
+        if not posting.is_valid():
             return Response(posting.errors, status=400)
+
+        posting.save()
+
+        return Response(
+            {
+                "id": thread.pk,
+                "title": thread.title,
+                "url": thread.get_absolute_url(),
+            }
+        )

misago/threads/forms.py

@@ -97,9 +97,8 @@ class AttachmentTypeForm(forms.ModelForm):
 
     def clean_mimetypes(self):
         data = self.cleaned_data["mimetypes"]
-        if not data:
-            return None
-        return self.clean_list(data)
+        if data:
+            return self.clean_list(data)
 
     def clean_list(self, value):
         items = [v.lstrip(".") for v in value.lower().replace(" ", "").split(",")]

misago/threads/models/attachment.py

@@ -94,8 +94,6 @@ class Attachment(models.Model):
                 "misago:attachment-thumbnail",
                 kwargs={"pk": self.pk, "secret": self.secret},
             )
-        else:
-            return None
 
     def set_file(self, upload):
         self.file = File(upload, upload.name)

misago/threads/models/poll.py

@@ -39,7 +39,6 @@ class Poll(models.Model):
     def ends_on(self):
         if self.length:
             return self.posted_on + timedelta(days=self.length)
-        return None
 
     @property
     def is_over(self):

misago/threads/models/post.py

@@ -208,10 +208,8 @@ class Post(models.Model):
         if self.is_valid:
             if len(self.original) > 150:
                 return str("%s...") % self.original[:150].strip()
-            else:
-                return self.original
-        else:
-            return ""
+            return self.original
+        return ""
 
     @property
     def is_valid(self):

misago/threads/moderation/posts.py

@@ -15,37 +15,37 @@ __all__ = [
 
 
 def approve_post(user, post):
-    if post.is_unapproved:
-        post.is_unapproved = False
-        post.save(update_fields=["is_unapproved"])
-        return True
-    else:
+    if not post.is_unapproved:
         return False
 
+    post.is_unapproved = False
+    post.save(update_fields=["is_unapproved"])
+    return True
+
 
 def protect_post(user, post):
-    if not post.is_protected:
-        post.is_protected = True
-        post.save(update_fields=["is_protected"])
-        if post.is_best_answer:
-            post.thread.best_answer_is_protected = True
-            post.thread.save(update_fields=["best_answer_is_protected"])
-        return True
-    else:
+    if post.is_protected:
         return False
 
+    post.is_protected = True
+    post.save(update_fields=["is_protected"])
+    if post.is_best_answer:
+        post.thread.best_answer_is_protected = True
+        post.thread.save(update_fields=["best_answer_is_protected"])
+    return True
+
 
 def unprotect_post(user, post):
-    if post.is_protected:
-        post.is_protected = False
-        post.save(update_fields=["is_protected"])
-        if post.is_best_answer:
-            post.thread.best_answer_is_protected = False
-            post.thread.save(update_fields=["best_answer_is_protected"])
-        return True
-    else:
+    if not post.is_protected:
         return False
 
+    post.is_protected = False
+    post.save(update_fields=["is_protected"])
+    if post.is_best_answer:
+        post.thread.best_answer_is_protected = False
+        post.thread.save(update_fields=["best_answer_is_protected"])
+    return True
+
 
 def unhide_post(user, post):
     if post.is_first_post:
@@ -53,37 +53,37 @@ def unhide_post(user, post):
             _("You can't make original post visible without revealing thread.")
         )
 
-    if post.is_hidden:
-        post.is_hidden = False
-        post.save(update_fields=["is_hidden"])
-        return True
-    else:
+    if not post.is_hidden:
         return False
 
+    post.is_hidden = False
+    post.save(update_fields=["is_hidden"])
+    return True
+
 
 def hide_post(user, post):
     if post.is_first_post:
         raise ModerationError(_("You can't hide original post without hiding thread."))
 
-    if not post.is_hidden:
-        post.is_hidden = True
-        post.hidden_by = user
-        post.hidden_by_name = user.username
-        post.hidden_by_slug = user.slug
-        post.hidden_on = timezone.now()
-        post.save(
-            update_fields=[
-                "is_hidden",
-                "hidden_by",
-                "hidden_by_name",
-                "hidden_by_slug",
-                "hidden_on",
-            ]
-        )
-        return True
-    else:
+    if post.is_hidden:
         return False
 
+    post.is_hidden = True
+    post.hidden_by = user
+    post.hidden_by_name = user.username
+    post.hidden_by_slug = user.slug
+    post.hidden_on = timezone.now()
+    post.save(
+        update_fields=[
+            "is_hidden",
+            "hidden_by",
+            "hidden_by_name",
+            "hidden_by_slug",
+            "hidden_on",
+        ]
+    )
+    return True
+
 
 @transaction.atomic
 def delete_post(user, post):

misago/threads/moderation/threads.py

@@ -21,74 +21,74 @@ __all__ = [
 
 @transaction.atomic
 def change_thread_title(request, thread, new_title):
-    if thread.title != new_title:
-        old_title = thread.title
-        thread.set_title(new_title)
-        thread.save(update_fields=["title", "slug"])
+    if thread.title == new_title:
+        return False
 
-        thread.first_post.set_search_document(thread.title)
-        thread.first_post.save(update_fields=["search_document"])
+    old_title = thread.title
+    thread.set_title(new_title)
+    thread.save(update_fields=["title", "slug"])
 
-        thread.first_post.update_search_vector()
-        thread.first_post.save(update_fields=["search_vector"])
+    thread.first_post.set_search_document(thread.title)
+    thread.first_post.save(update_fields=["search_document"])
 
-        record_event(request, thread, "changed_title", {"old_title": old_title})
-        return True
-    else:
-        return False
+    thread.first_post.update_search_vector()
+    thread.first_post.save(update_fields=["search_vector"])
+
+    record_event(request, thread, "changed_title", {"old_title": old_title})
+    return True
 
 
 @transaction.atomic
 def pin_thread_globally(request, thread):
-    if thread.weight != 2:
-        thread.weight = 2
-        record_event(request, thread, "pinned_globally")
-        return True
-    else:
+    if thread.weight == 2:
         return False
 
+    thread.weight = 2
+    record_event(request, thread, "pinned_globally")
+    return True
+
 
 @transaction.atomic
 def pin_thread_locally(request, thread):
-    if thread.weight != 1:
-        thread.weight = 1
-        record_event(request, thread, "pinned_locally")
-        return True
-    else:
+    if thread.weight == 1:
         return False
 
+    thread.weight = 1
+    record_event(request, thread, "pinned_locally")
+    return True
+
 
 @transaction.atomic
 def unpin_thread(request, thread):
-    if thread.weight:
-        thread.weight = 0
-        record_event(request, thread, "unpinned")
-        return True
-    else:
+    if thread.weight == 0:
         return False
 
+    thread.weight = 0
+    record_event(request, thread, "unpinned")
+    return True
+
 
 @transaction.atomic
 def move_thread(request, thread, new_category):
-    if thread.category_id != new_category.pk:
-        from_category = thread.category
-        thread.move(new_category)
-
-        record_event(
-            request,
-            thread,
-            "moved",
-            {
-                "from_category": {
-                    "name": from_category.name,
-                    "url": from_category.get_absolute_url(),
-                }
-            },
-        )
-        return True
-    else:
+    if thread.category_id == new_category.pk:
         return False
 
+    from_category = thread.category
+    thread.move(new_category)
+
+    record_event(
+        request,
+        thread,
+        "moved",
+        {
+            "from_category": {
+                "name": from_category.name,
+                "url": from_category.get_absolute_url(),
+            }
+        },
+    )
+    return True
+
 
 @transaction.atomic
 def merge_thread(request, thread, other_thread):
@@ -101,88 +101,88 @@ def merge_thread(request, thread, other_thread):
 
 @transaction.atomic
 def approve_thread(request, thread):
-    if thread.is_unapproved:
-        thread.first_post.is_unapproved = False
-        thread.first_post.save(update_fields=["is_unapproved"])
+    if not thread.is_unapproved:
+        return False
 
-        thread.is_unapproved = False
+    thread.first_post.is_unapproved = False
+    thread.first_post.save(update_fields=["is_unapproved"])
 
-        unapproved_post_qs = thread.post_set.filter(is_unapproved=True)
-        thread.has_unapproved_posts = unapproved_post_qs.exists()
+    thread.is_unapproved = False
 
-        record_event(request, thread, "approved")
-        return True
-    else:
-        return False
+    unapproved_post_qs = thread.post_set.filter(is_unapproved=True)
+    thread.has_unapproved_posts = unapproved_post_qs.exists()
+
+    record_event(request, thread, "approved")
+    return True
 
 
 @transaction.atomic
 def open_thread(request, thread):
-    if thread.is_closed:
-        thread.is_closed = False
-        record_event(request, thread, "opened")
-        return True
-    else:
+    if not thread.is_closed:
         return False
 
+    thread.is_closed = False
+    record_event(request, thread, "opened")
+    return True
+
 
 @transaction.atomic
 def close_thread(request, thread):
-    if not thread.is_closed:
-        thread.is_closed = True
-        record_event(request, thread, "closed")
-        return True
-    else:
+    if thread.is_closed:
         return False
 
+    thread.is_closed = True
+    record_event(request, thread, "closed")
+    return True
+
 
 @transaction.atomic
 def unhide_thread(request, thread):
-    if thread.is_hidden:
-        thread.first_post.is_hidden = False
-        thread.first_post.save(update_fields=["is_hidden"])
-        thread.is_hidden = False
+    if not thread.is_hidden:
+        return False
 
-        record_event(request, thread, "unhid")
+    thread.first_post.is_hidden = False
+    thread.first_post.save(update_fields=["is_hidden"])
+    thread.is_hidden = False
 
-        if thread.pk == thread.category.last_thread_id:
-            thread.category.synchronize()
-            thread.category.save()
+    record_event(request, thread, "unhid")
 
-        return True
-    else:
-        return False
+    if thread.pk == thread.category.last_thread_id:
+        thread.category.synchronize()
+        thread.category.save()
+
+    return True
 
 
 @transaction.atomic
 def hide_thread(request, thread):
-    if not thread.is_hidden:
-        thread.first_post.is_hidden = True
-        thread.first_post.hidden_by = request.user
-        thread.first_post.hidden_by_name = request.user.username
-        thread.first_post.hidden_by_slug = request.user.slug
-        thread.first_post.hidden_on = timezone.now()
-        thread.first_post.save(
-            update_fields=[
-                "is_hidden",
-                "hidden_by",
-                "hidden_by_name",
-                "hidden_by_slug",
-                "hidden_on",
-            ]
-        )
-        thread.is_hidden = True
-
-        record_event(request, thread, "hid")
-
-        if thread.pk == thread.category.last_thread_id:
-            thread.category.synchronize()
-            thread.category.save()
-
-        return True
-    else:
+    if thread.is_hidden:
         return False
 
+    thread.first_post.is_hidden = True
+    thread.first_post.hidden_by = request.user
+    thread.first_post.hidden_by_name = request.user.username
+    thread.first_post.hidden_by_slug = request.user.slug
+    thread.first_post.hidden_on = timezone.now()
+    thread.first_post.save(
+        update_fields=[
+            "is_hidden",
+            "hidden_by",
+            "hidden_by_name",
+            "hidden_by_slug",
+            "hidden_on",
+        ]
+    )
+    thread.is_hidden = True
+
+    record_event(request, thread, "hid")
+
+    if thread.pk == thread.category.last_thread_id:
+        thread.category.synchronize()
+        thread.category.save()
+
+    return True
+
 
 @transaction.atomic
 def delete_thread(request, thread):

misago/threads/permissions/attachments.py

@@ -35,12 +35,9 @@ class AnonymousPermissionsForm(forms.Form):
 
 def change_permissions_form(role):
     if isinstance(role, Role):
-        if role.special_role != "anonymous":
-            return PermissionsForm
-        else:
+        if role.special_role == "anonymous":
             return AnonymousPermissionsForm
-    else:
-        return None
+        return PermissionsForm
 
 
 def build_acl(acl, roles, key_name):

misago/threads/permissions/bestanswers.py

@@ -54,8 +54,6 @@ class CategoryPermissionsForm(forms.Form):
 def change_permissions_form(role):
     if isinstance(role, CategoryRole):
         return CategoryPermissionsForm
-    else:
-        return None
 
 
 def build_acl(acl, roles, key_name):
@@ -377,5 +375,5 @@ def has_time_to_change_answer(user_acl, target):
         diff = timezone.now() - target.best_answer_marked_on
         diff_minutes = int(diff.total_seconds() / 60)
         return diff_minutes < change_time
-    else:
-        return True
+
+    return True

misago/threads/permissions/polls.py

@@ -62,8 +62,6 @@ class RolePermissionsForm(forms.Form):
 def change_permissions_form(role):
     if isinstance(role, Role) and role.special_role != "anonymous":
         return RolePermissionsForm
-    else:
-        return None
 
 
 def build_acl(acl, roles, key_name):
@@ -253,7 +251,6 @@ def has_time_to_edit_poll(user_acl, target):
     if edit_time:
         diff = timezone.now() - target.posted_on
         diff_minutes = int(diff.total_seconds() / 60)
-
         return diff_minutes < edit_time
-    else:
-        return True
+
+    return True

misago/threads/permissions/privatethreads.py

@@ -65,8 +65,6 @@ class PermissionsForm(forms.Form):
 def change_permissions_form(role):
     if isinstance(role, Role) and role.special_role != "anonymous":
         return PermissionsForm
-    else:
-        return None
 
 
 def build_acl(acl, roles, key_name):

misago/threads/permissions/threads.py

@@ -226,10 +226,8 @@ class CategoryPermissionsForm(forms.Form):
 def change_permissions_form(role):
     if isinstance(role, Role) and role.special_role != "anonymous":
         return RolePermissionsForm
-    elif isinstance(role, CategoryRole):
+    if isinstance(role, CategoryRole):
         return CategoryPermissionsForm
-    else:
-        return None
 
 
 def build_acl(acl, roles, key_name):
@@ -1288,8 +1286,8 @@ def has_time_to_edit_thread(user_acl, target):
         diff = timezone.now() - target.started_on
         diff_minutes = int(diff.total_seconds() / 60)
         return diff_minutes < edit_time
-    else:
-        return True
+
+    return True
 
 
 def has_time_to_edit_post(user_acl, target):
@@ -1300,8 +1298,8 @@ def has_time_to_edit_post(user_acl, target):
         diff = timezone.now() - target.posted_on
         diff_minutes = int(diff.total_seconds() / 60)
         return diff_minutes < edit_time
-    else:
-        return True
+
+    return True
 
 
 def exclude_invisible_threads(user_acl, categories, queryset):
@@ -1399,17 +1397,16 @@ def exclude_invisible_threads(user_acl, categories, queryset):
         else:
             conditions = condition
 
-    if conditions:
-        return queryset.filter(conditions)
-    else:
+    if not conditions:
         return Thread.objects.none()
+    
+    return queryset.filter(conditions)
 
 
 def exclude_invisible_posts(user_acl, categories, queryset):
     if hasattr(categories, "__iter__"):
         return exclude_invisible_posts_in_categories(user_acl, categories, queryset)
-    else:
-        return exclude_invisible_posts_in_category(user_acl, categories, queryset)
+    return exclude_invisible_posts_in_category(user_acl, categories, queryset)
 
 
 def exclude_invisible_posts_in_categories(user_acl, categories, queryset):
@@ -1461,11 +1458,11 @@ def exclude_invisible_posts_in_categories(user_acl, categories, queryset):
             category__in=hide_invisible_events, is_event=True, is_hidden=True
         )
 
-    if conditions:
-        return queryset.filter(conditions)
-    else:
+    if not conditions:
         return Post.objects.none()
 
+    return queryset.filter(conditions)
+
 
 def exclude_invisible_posts_in_category(user_acl, category, queryset):
     add_acl_to_obj(user_acl, category)

misago/threads/serializers/attachment.py

@@ -54,5 +54,3 @@ class AttachmentSerializer(serializers.ModelSerializer):
             return reverse(
                 "misago:user", kwargs={"slug": obj.uploader_slug, "pk": obj.uploader_id}
             )
-        else:
-            return None

misago/threads/serializers/poll.py

@@ -52,8 +52,6 @@ class PollSerializer(serializers.ModelSerializer):
             return reverse(
                 "misago:user", kwargs={"slug": obj.poster_slug, "pk": obj.poster_id}
             )
-        else:
-            return None
 
     def get_acl(self, obj):
         try:

misago/threads/serializers/post.py

@@ -79,8 +79,6 @@ class PostSerializer(serializers.ModelSerializer, MutableFields):
             and (not obj.is_hidden or obj.acl["can_see_hidden"])
         ):
             return obj.content
-        else:
-            return None
 
     def get_attachments(self, obj):
         return obj.attachments_cache
@@ -156,8 +154,6 @@ class PostSerializer(serializers.ModelSerializer, MutableFields):
                 "misago:user",
                 kwargs={"pk": obj.last_editor_id, "slug": obj.last_editor_slug},
             )
-        else:
-            return None
 
     def get_hidden_by_url(self, obj):
         if obj.hidden_by_id:
@@ -165,5 +161,3 @@ class PostSerializer(serializers.ModelSerializer, MutableFields):
                 "misago:user",
                 kwargs={"pk": obj.hidden_by_id, "slug": obj.hidden_by_slug},
             )
-        else:
-            return None

misago/threads/serializers/postedit.py

@@ -26,5 +26,3 @@ class PostEditSerializer(serializers.ModelSerializer):
             return reverse(
                 "misago:user", kwargs={"slug": obj.editor_slug, "pk": obj.editor_id}
             )
-        else:
-            return None

misago/threads/serializers/postlike.py

@@ -31,5 +31,3 @@ class PostLikeSerializer(serializers.ModelSerializer):
             return reverse(
                 "misago:user", kwargs={"slug": obj["liker_slug"], "pk": obj["liker_id"]}
             )
-        else:
-            return None

misago/threads/serializers/thread.py

@@ -138,7 +138,6 @@ class ThreadSerializer(serializers.ModelSerializer, MutableFields):
             return reverse(
                 "misago:user", kwargs={"slug": obj.starter_slug, "pk": obj.starter_id}
             )
-        return None
 
     def get_last_poster_url(self, obj):
         if obj.last_poster_id:
@@ -146,7 +145,6 @@ class ThreadSerializer(serializers.ModelSerializer, MutableFields):
                 "misago:user",
                 kwargs={"slug": obj.last_poster_slug, "pk": obj.last_poster_id},
             )
-        return None
 
 
 class PrivateThreadSerializer(ThreadSerializer):
@@ -175,7 +173,6 @@ class ThreadsListSerializer(ThreadSerializer):
                 "real_name": obj.starter.get_real_name(),
                 "avatars": obj.starter.avatars,
             }
-        return None
 
     def get_last_poster(self, obj):
         if obj.last_poster_id:
@@ -185,7 +182,6 @@ class ThreadsListSerializer(ThreadSerializer):
                 "real_name": obj.last_poster.get_real_name(),
                 "avatars": obj.last_poster.avatars,
             }
-        return None
 
 
 ThreadsListSerializer = ThreadsListSerializer.exclude_fields("path", "poll")

misago/threads/threadtypes/privatethread.py

@@ -38,10 +38,10 @@ class PrivateThread(ThreadType):
                 "misago:private-thread",
                 kwargs={"slug": thread.slug, "pk": thread.pk, "page": page},
             )
-        else:
-            return reverse(
-                "misago:private-thread", kwargs={"slug": thread.slug, "pk": thread.pk}
-            )
+
+        return reverse(
+            "misago:private-thread", kwargs={"slug": thread.slug, "pk": thread.pk}
+        )
 
     def get_thread_last_post_url(self, thread):
         return reverse(

misago/threads/threadtypes/thread.py

@@ -11,16 +11,15 @@ class Thread(ThreadType):
     def get_category_name(self, category):
         if category.level:
             return category.name
-        else:
-            return _("None (will become top level category)")
+        return _("None (will become top level category)")
 
     def get_category_absolute_url(self, category):
         if category.level:
             return reverse(
                 "misago:category", kwargs={"pk": category.pk, "slug": category.slug}
             )
-        else:
-            return reverse("misago:threads")
+        
+        return reverse("misago:threads")
 
     def get_category_last_thread_url(self, category):
         return reverse(
@@ -46,10 +45,10 @@ class Thread(ThreadType):
                 "misago:thread",
                 kwargs={"slug": thread.slug, "pk": thread.pk, "page": page},
             )
-        else:
-            return reverse(
-                "misago:thread", kwargs={"slug": thread.slug, "pk": thread.pk}
-            )
+
+        return reverse(
+            "misago:thread", kwargs={"slug": thread.slug, "pk": thread.pk}
+        )
 
     def get_thread_last_post_url(self, thread):
         return reverse(

misago/threads/viewmodels/threads.py

@@ -154,14 +154,12 @@ class ForumThreads(ViewModel):
             return list(queryset.filter(weight=2)) + list(
                 queryset.filter(weight=1, category__in=threads_categories)
             )
-        else:
-            return queryset.filter(weight=2)
+        return queryset.filter(weight=2)
 
     def get_remaining_threads_queryset(self, queryset, category, threads_categories):
         if category.level:
             return queryset.filter(weight=0, category__in=threads_categories)
-        else:
-            return queryset.filter(weight__lt=2, category__in=threads_categories)
+        return queryset.filter(weight__lt=2, category__in=threads_categories)
 
 
 class PrivateThreads(ViewModel):
@@ -189,25 +187,22 @@ class PrivateThreads(ViewModel):
 
 def get_threads_queryset(request, categories, list_type):
     queryset = exclude_invisible_threads(request.user_acl, categories, Thread.objects)
-
     if list_type == "all":
         return queryset
-    else:
-        return filter_threads_queryset(request, categories, list_type, queryset)
+    return filter_threads_queryset(request, categories, list_type, queryset)
 
 
 def filter_threads_queryset(request, categories, list_type, queryset):
     if list_type == "my":
         return queryset.filter(starter=request.user)
-    elif list_type == "subscribed":
+    if list_type == "subscribed":
         subscribed_threads = request.user.subscription_set.values("thread_id")
         return queryset.filter(id__in=subscribed_threads)
-    elif list_type == "unapproved":
+    if list_type == "unapproved":
         return queryset.filter(has_unapproved_posts=True)
-    elif list_type in ("new", "unread"):
+    if list_type in ("new", "unread"):
         return filter_read_threads_queryset(request, categories, list_type, queryset)
-    else:
-        return queryset
+    return queryset
 
 
 def filter_read_threads_queryset(request, categories, list_type, queryset):

misago/threads/views/attachment.py

@@ -34,13 +34,11 @@ def serve_file(request, pk, secret, thumbnail):
     if attachment.is_image:
         if thumbnail:
             return attachment.thumbnail.url
-        else:
-            return attachment.image.url
-    else:
-        if thumbnail:
-            raise Http404()
-        else:
-            return attachment.file.url
+        return attachment.image.url
+
+    if thumbnail:
+        raise Http404()
+    return attachment.file.url
 
 
 def allow_file_download(request, attachment):

misago/threads/views/goto.py

@@ -137,8 +137,7 @@ class ThreadGotoUnapprovedView(GotoView):
         )
         if unapproved_post:
             return unapproved_post
-        else:
-            return posts_queryset.order_by("id").last()
+        return posts_queryset.order_by("id").last()
 
 
 class PrivateThreadGotoPostView(GotoView):

misago/users/api/auth.py

@@ -26,8 +26,7 @@ User = auth.get_user_model()
 def gateway(request):
     if request.method == "POST":
         return login(request)
-    else:
-        return session_user(request)
+    return session_user(request)
 
 
 @api_view(["POST"])
@@ -43,8 +42,7 @@ def login(request):
     if form.is_valid():
         auth.login(request, form.user_cache)
         return Response(AuthenticatedUserSerializer(form.user_cache).data)
-    else:
-        return Response(form.get_errors_dict(), status=status.HTTP_400_BAD_REQUEST)
+    return Response(form.get_errors_dict(), status=status.HTTP_400_BAD_REQUEST)
 
 
 @api_view()
@@ -72,9 +70,7 @@ def get_criteria(request):
 
     for validator in settings.AUTH_PASSWORD_VALIDATORS:
         validator_dict = {"name": validator["NAME"].split(".")[-1]}
-
         validator_dict.update(validator.get("OPTIONS", {}))
-
         criteria["password"].append(validator_dict)
 
     return Response(criteria)
@@ -90,30 +86,30 @@ def send_activation(request):
     will mail account activation link to requester
     """
     form = ResendActivationForm(request.data)
-    if form.is_valid():
-        requesting_user = form.user_cache
-
-        mail_subject = _("Activate %(user)s account on %(forum_name)s forums") % {
-            "user": requesting_user.username,
-            "forum_name": request.settings.forum_name,
-        }
-
-        mail_user(
-            requesting_user,
-            mail_subject,
-            "misago/emails/activation/by_user",
-            context={
-                "activation_token": make_activation_token(requesting_user),
-                "settings": request.settings,
-            },
-        )
-
-        return Response(
-            {"username": form.user_cache.username, "email": form.user_cache.email}
-        )
-    else:
+    if not form.is_valid():
         return Response(form.get_errors_dict(), status=status.HTTP_400_BAD_REQUEST)
 
+    requesting_user = form.user_cache
+
+    mail_subject = _("Activate %(user)s account on %(forum_name)s forums") % {
+        "user": requesting_user.username,
+        "forum_name": request.settings.forum_name,
+    }
+
+    mail_user(
+        requesting_user,
+        mail_subject,
+        "misago/emails/activation/by_user",
+        context={
+            "activation_token": make_activation_token(requesting_user),
+            "settings": request.settings,
+        },
+    )
+
+    return Response(
+        {"username": form.user_cache.username, "email": form.user_cache.email}
+    )
+
 
 @api_view(["POST"])
 @permission_classes((UnbannedOnly,))
@@ -125,32 +121,32 @@ def send_password_form(request):
     will mail change password form link to requester
     """
     form = ResetPasswordForm(request.data)
-    if form.is_valid():
-        requesting_user = form.user_cache
-
-        mail_subject = _("Change %(user)s password on %(forum_name)s forums") % {
-            "user": requesting_user.username,
-            "forum_name": request.settings.forum_name,
-        }
-
-        confirmation_token = make_password_change_token(requesting_user)
-
-        mail_user(
-            requesting_user,
-            mail_subject,
-            "misago/emails/change_password_form_link",
-            context={
-                "confirmation_token": confirmation_token,
-                "settings": request.settings,
-            },
-        )
-
-        return Response(
-            {"username": form.user_cache.username, "email": form.user_cache.email}
-        )
-    else:
+    if not form.is_valid():
         return Response(form.get_errors_dict(), status=status.HTTP_400_BAD_REQUEST)
 
+    requesting_user = form.user_cache
+
+    mail_subject = _("Change %(user)s password on %(forum_name)s forums") % {
+        "user": requesting_user.username,
+        "forum_name": request.settings.forum_name,
+    }
+
+    confirmation_token = make_password_change_token(requesting_user)
+
+    mail_user(
+        requesting_user,
+        mail_subject,
+        "misago/emails/change_password_form_link",
+        context={
+            "confirmation_token": confirmation_token,
+            "settings": request.settings,
+        },
+    )
+
+    return Response(
+        {"username": form.user_cache.username, "email": form.user_cache.email}
+    )
+
 
 class PasswordChangeFailed(Exception):
     pass

misago/users/api/captcha.py

@@ -5,12 +5,12 @@ from rest_framework.response import Response
 
 @api_view()
 def question(request):
-    if request.settings.qa_question:
-        return Response(
-            {
-                "question": request.settings.qa_question,
-                "help_text": request.settings.qa_help_text,
-            }
-        )
-    else:
+    if not request.settings.qa_question:
         raise Http404()
+    
+    return Response(
+        {
+            "question": request.settings.qa_question,
+            "help_text": request.settings.qa_help_text,
+        }
+    )

misago/users/api/userendpoints/avatar.py

@@ -32,8 +32,7 @@ def avatar_endpoint(request, pk=None):
     avatar_options = get_avatar_options(request, request.user)
     if request.method == "POST":
         return avatar_post(request, avatar_options)
-    else:
-        return Response(avatar_options)
+    return Response(avatar_options)
 
 
 def get_avatar_options(request, user):
@@ -206,26 +205,26 @@ def moderate_avatar_endpoint(request, profile):
     if request.method == "POST":
         is_avatar_locked = profile.is_avatar_locked
         serializer = ModerateAvatarSerializer(profile, data=request.data)
-        if serializer.is_valid():
-            if serializer.validated_data["is_avatar_locked"] and not is_avatar_locked:
-                avatars.dynamic.set_avatar(profile)
-            serializer.save()
-
-            return Response(
-                {
-                    "avatars": profile.avatars,
-                    "is_avatar_locked": int(profile.is_avatar_locked),
-                    "avatar_lock_user_message": profile.avatar_lock_user_message,
-                    "avatar_lock_staff_message": profile.avatar_lock_staff_message,
-                }
-            )
-        else:
+        if not serializer.is_valid():
             return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-    else:
+
+        if serializer.validated_data["is_avatar_locked"] and not is_avatar_locked:
+            avatars.dynamic.set_avatar(profile)
+        serializer.save()
+
         return Response(
             {
+                "avatars": profile.avatars,
                 "is_avatar_locked": int(profile.is_avatar_locked),
                 "avatar_lock_user_message": profile.avatar_lock_user_message,
                 "avatar_lock_staff_message": profile.avatar_lock_staff_message,
             }
         )
+    
+    return Response(
+        {
+            "is_avatar_locked": int(profile.is_avatar_locked),
+            "avatar_lock_user_message": profile.avatar_lock_user_message,
+            "avatar_lock_staff_message": profile.avatar_lock_staff_message,
+        }
+    )

misago/users/api/userendpoints/changeemail.py

@@ -12,25 +12,25 @@ def change_email_endpoint(request, pk=None):
         data=request.data, context={"user": request.user}
     )
 
-    if serializer.is_valid():
-        token = store_new_credential(
-            request, "email", serializer.validated_data["new_email"]
-        )
-
-        mail_subject = _("Confirm e-mail change on %(forum_name)s forums")
-        mail_subject = mail_subject % {"forum_name": request.settings.forum_name}
-
-        # swap address with new one so email is sent to new address
-        request.user.email = serializer.validated_data["new_email"]
-
-        mail_user(
-            request.user,
-            mail_subject,
-            "misago/emails/change_email",
-            context={"settings": request.settings, "token": token},
-        )
-
-        message = _("E-mail change confirmation link was sent to new address.")
-        return Response({"detail": message})
-    else:
+    if not serializer.is_valid():
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    token = store_new_credential(
+        request, "email", serializer.validated_data["new_email"]
+    )
+
+    mail_subject = _("Confirm e-mail change on %(forum_name)s forums")
+    mail_subject = mail_subject % {"forum_name": request.settings.forum_name}
+
+    # swap address with new one so email is sent to new address
+    request.user.email = serializer.validated_data["new_email"]
+
+    mail_user(
+        request.user,
+        mail_subject,
+        "misago/emails/change_email",
+        context={"settings": request.settings, "token": token},
+    )
+
+    message = _("E-mail change confirmation link was sent to new address.")
+    return Response({"detail": message})

misago/users/api/userendpoints/changepassword.py

@@ -12,23 +12,23 @@ def change_password_endpoint(request, pk=None):
         data=request.data, context={"user": request.user}
     )
 
-    if serializer.is_valid():
-        token = store_new_credential(
-            request, "password", serializer.validated_data["new_password"]
-        )
-
-        mail_subject = _("Confirm password change on %(forum_name)s forums")
-        mail_subject = mail_subject % {"forum_name": request.settings.forum_name}
-
-        mail_user(
-            request.user,
-            mail_subject,
-            "misago/emails/change_password",
-            context={"settings": request.settings, "token": token},
-        )
-
-        return Response(
-            {"detail": _("Password change confirmation link was sent to your address.")}
-        )
-    else:
+    if not serializer.is_valid():
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    token = store_new_credential(
+        request, "password", serializer.validated_data["new_password"]
+    )
+
+    mail_subject = _("Confirm password change on %(forum_name)s forums")
+    mail_subject = mail_subject % {"forum_name": request.settings.forum_name}
+
+    mail_user(
+        request.user,
+        mail_subject,
+        "misago/emails/change_password",
+        context={"settings": request.settings, "token": token},
+    )
+
+    return Response(
+        {"detail": _("Password change confirmation link was sent to your address.")}
+    )

misago/users/api/userendpoints/list.py

@@ -36,8 +36,7 @@ def list_endpoint(request):
 
     if list_handler:
         return list_handler(request)
-    else:
-        return rank_users(request)
+    return rank_users(request)
 
 
 ScoredUserSerializer = UserCardSerializer.extend_fields("meta")

misago/users/api/userendpoints/username.py

@@ -10,9 +10,9 @@ from ...serializers import ChangeUsernameSerializer
 def username_endpoint(request):
     if request.method == "POST":
         return change_username(request)
-    else:
-        options = get_username_options_from_request(request)
-        return options_response(options)
+
+    options = get_username_options_from_request(request)
+    return options_response(options)
 
 
 def get_username_options_from_request(request):
@@ -36,31 +36,31 @@ def change_username(request):
     serializer = ChangeUsernameSerializer(
         data=request.data, context={"settings": request.settings, "user": request.user}
     )
-    if serializer.is_valid():
-        try:
-            serializer.change_username(changed_by=request.user)
-            updated_options = get_username_options_from_request(request)
-            if updated_options["next_on"]:
-                updated_options["next_on"] = updated_options["next_on"].isoformat()
-
-            return Response(
-                {
-                    "username": request.user.username,
-                    "slug": request.user.slug,
-                    "options": updated_options,
-                }
-            )
-        except IntegrityError:
-            return Response(
-                {"detail": _("Error changing username. Please try again.")},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-    else:
+    if not serializer.is_valid():
         return Response(
             {"detail": serializer.errors["non_field_errors"][0]},
             status=status.HTTP_400_BAD_REQUEST,
         )
 
+    try:
+        serializer.change_username(changed_by=request.user)
+        updated_options = get_username_options_from_request(request)
+        if updated_options["next_on"]:
+            updated_options["next_on"] = updated_options["next_on"].isoformat()
+
+        return Response(
+            {
+                "username": request.user.username,
+                "slug": request.user.slug,
+                "options": updated_options,
+            }
+        )
+    except IntegrityError:
+        return Response(
+            {"detail": _("Error changing username. Please try again.")},
+            status=status.HTTP_400_BAD_REQUEST,
+        )
+
 
 def moderate_username_endpoint(request, profile):
     if request.method == "POST":
@@ -68,24 +68,24 @@ def moderate_username_endpoint(request, profile):
             data=request.data, context={"settings": request.settings, "user": profile}
         )
 
-        if serializer.is_valid():
-            try:
-                serializer.change_username(changed_by=request.user)
-                return Response({"username": profile.username, "slug": profile.slug})
-            except IntegrityError:
-                return Response(
-                    {"detail": _("Error changing username. Please try again.")},
-                    status=status.HTTP_400_BAD_REQUEST,
-                )
-        else:
+        if not serializer.is_valid():
             return Response(
                 {"detail": serializer.errors["non_field_errors"][0]},
                 status=status.HTTP_400_BAD_REQUEST,
             )
-    else:
-        return Response(
-            {
-                "length_min": request.settings.username_length_min,
-                "length_max": request.settings.username_length_max,
-            }
-        )
+
+        try:
+            serializer.change_username(changed_by=request.user)
+            return Response({"username": profile.username, "slug": profile.slug})
+        except IntegrityError:
+            return Response(
+                {"detail": _("Error changing username. Please try again.")},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+    return Response(
+        {
+            "length_min": request.settings.username_length_min,
+            "length_max": request.settings.username_length_max,
+        }
+    )

misago/users/api/usernamechanges.py

@@ -23,7 +23,7 @@ class UsernameChangesViewSetPermission(BasePermission):
 
         if user_pk == request.user.pk:
             return True
-        elif not request.user_acl.get("can_see_users_name_history"):
+        if not request.user_acl.get("can_see_users_name_history"):
             raise PermissionDenied(
                 _("You don't have permission to see other users name history.")
             )

misago/users/api/users.py

@@ -120,8 +120,7 @@ class UserViewSet(viewsets.GenericViewSet):
         if serializer.is_valid():
             serializer.save()
             return Response({"detail": _("Your forum options have been changed.")})
-        else:
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 
     @detail_route(methods=["get", "post"])
     def username(self, request, pk=None):
@@ -210,8 +209,7 @@ class UserViewSet(viewsets.GenericViewSet):
         ban = get_user_ban(profile, request.cache_versions)
         if ban:
             return Response(BanDetailsSerializer(ban).data)
-        else:
-            return Response({})
+        return Response({})
 
     @detail_route(methods=["get", "post"])
     def moderate_avatar(self, request, pk=None):

misago/users/apps.py

@@ -72,19 +72,15 @@ class MisagoUsersConfig(AppConfig):
                 is_account_owner = profile.pk == request.user.pk
                 has_permission = request.user_acl["can_see_users_name_history"]
                 return is_account_owner or has_permission
-            else:
-                return False
+            return False
 
         def can_see_ban_details(request, profile):
             if request.user.is_authenticated:
                 if request.user_acl["can_see_ban_details"]:
                     from .bans import get_user_ban
-
                     return bool(get_user_ban(profile, request.cache_versions))
-                else:
-                    return False
-            else:
                 return False
+            return False
 
         user_profile.add_section(
             link="misago:user-posts", name=_("Posts"), icon="message", component="posts"

misago/users/bans.py

@@ -54,8 +54,6 @@ def get_user_ban(user, cache_versions):
 
     if user.ban_cache.ban:
         return user.ban_cache
-    else:
-        return None
 
 
 def _set_user_ban_cache(user, cache_versions):
@@ -92,8 +90,7 @@ def get_request_ip_ban(request):
     if session_ban_cache:
         if session_ban_cache["is_banned"]:
             return session_ban_cache
-        else:
-            return False
+        return False
 
     found_ban = get_ip_ban(request.user_ip)
 
@@ -111,10 +108,9 @@ def get_request_ip_ban(request):
         ban_cache.update({"is_banned": True, "message": found_ban.user_message})
         request.session[CACHE_SESSION_KEY] = ban_cache
         return _hydrate_session_cache(request.session[CACHE_SESSION_KEY])
-    else:
-        ban_cache["is_banned"] = False
-        request.session[CACHE_SESSION_KEY] = ban_cache
-        return None
+
+    ban_cache["is_banned"] = False
+    request.session[CACHE_SESSION_KEY] = ban_cache
 
 
 def _get_session_bancache(request):

misago/users/models/ban.py

@@ -104,15 +104,13 @@ class Ban(models.Model):
     def is_expired(self):
         if self.expires_on:
             return self.expires_on < timezone.now()
-        else:
-            return False
+        return False
 
     def check_value(self, value):
         if "*" in self.banned_value:
             regex = re.escape(self.banned_value).replace("\*", "(.*?)")
             return re.search("^%s$" % regex, value, re.IGNORECASE) is not None
-        else:
-            return self.banned_value.lower() == value.lower()
+        return self.banned_value.lower() == value.lower()
 
     def lift(self):
         self.expires_on = timezone.now()

misago/users/permissions/account.py

@@ -37,8 +37,6 @@ class PermissionsForm(forms.Form):
 def change_permissions_form(role):
     if isinstance(role, Role) and role.special_role != "anonymous":
         return PermissionsForm
-    else:
-        return None
 
 
 def build_acl(acl, roles, key_name):

misago/users/permissions/decorators.py

@@ -6,19 +6,17 @@ __all__ = ["authenticated_only", "anonymous_only"]
 
 def authenticated_only(f):
     def perm_decorator(user_acl, target):
-        if user_acl["is_authenticated"]:
-            return f(user_acl, target)
-        else:
+        if user_acl["is_anonymous"]:
             raise PermissionDenied(_("You have to sig in to perform this action."))
+        return f(user_acl, target)
 
     return perm_decorator
 
 
 def anonymous_only(f):
     def perm_decorator(user_acl, target):
-        if user_acl["is_anonymous"]:
-            return f(user_acl, target)
-        else:
+        if user_acl["is_authenticated"]:
             raise PermissionDenied(_("Only guests can perform this action."))
+        return f(user_acl, target)
 
     return perm_decorator

misago/users/permissions/delete.py

@@ -40,8 +40,6 @@ class PermissionsForm(forms.Form):
 def change_permissions_form(role):
     if isinstance(role, Role) and role.special_role != "anonymous":
         return PermissionsForm
-    else:
-        return None
 
 
 def build_acl(acl, roles, key_name):

misago/users/permissions/moderation.py

@@ -55,8 +55,6 @@ class PermissionsForm(forms.Form):
 def change_permissions_form(role):
     if isinstance(role, Role) and role.special_role != "anonymous":
         return PermissionsForm
-    else:
-        return None
 
 
 def build_acl(acl, roles, key_name):

misago/users/permissions/profiles.py

@@ -58,10 +58,7 @@ def change_permissions_form(role):
     if isinstance(role, Role):
         if role.special_role == "anonymous":
             return LimitedPermissionsForm
-        else:
-            return PermissionsForm
-    else:
-        return None
+        return PermissionsForm
 
 
 def build_acl(acl, roles, key_name):

misago/users/profilefields/basefields.py

@@ -110,7 +110,6 @@ class ChoiceProfileField(ProfileField):
         for key, name in self.get_choices():
             if key == value:
                 return {"text": str(name)}
-        return None
 
     def search_users(self, criteria):
         """custom search implementation for choice fields"""

misago/users/serializers/ban.py

@@ -10,8 +10,6 @@ __all__ = ["BanMessageSerializer", "BanDetailsSerializer"]
 def serialize_message(message):
     if message:
         return {"plain": message, "html": format_plaintext_for_html(message)}
-    else:
-        return None
 
 
 class BanMessageSerializer(serializers.ModelSerializer):

misago/users/serializers/rank.py

@@ -27,8 +27,7 @@ class RankSerializer(serializers.ModelSerializer):
     def get_description(self, obj):
         if obj.description:
             return format_plaintext_for_html(obj.description)
-        else:
-            return ""
+        return ""
 
     def get_url(self, obj):
         return obj.get_absolute_url()

misago/users/serializers/user.py

@@ -72,22 +72,18 @@ class UserSerializer(serializers.ModelSerializer, MutableFields):
         request = self.context["request"]
         if obj == request.user or request.user_acl["can_see_users_emails"]:
             return obj.email
-        else:
-            return None
 
     def get_is_followed(self, obj):
         request = self.context["request"]
         if obj.acl["can_follow"]:
             return request.user.is_following(obj)
-        else:
-            return False
+        return False
 
     def get_is_blocked(self, obj):
         request = self.context["request"]
         if obj.acl["can_block"]:
             return request.user.is_blocking(obj)
-        else:
-            return False
+        return False
 
     def get_meta(self, obj):
         return {"score": obj.score}
@@ -98,8 +94,6 @@ class UserSerializer(serializers.ModelSerializer, MutableFields):
     def get_signature(self, obj):
         if obj.has_valid_signature:
             return obj.signature_parsed
-        else:
-            return None
 
     def get_status(self, obj):
         try:

misago/users/signatures.py

@@ -16,8 +16,7 @@ def is_user_signature_valid(user):
     if user.signature:
         valid_checksum = make_signature_checksum(user.signature_parsed, user)
         return user.signature_checksum == valid_checksum
-    else:
-        return False
+    return False
 
 
 def make_signature_checksum(parsed_signature, user):

misago/users/views/admin/users.py

@@ -252,8 +252,7 @@ class NewUser(UserAdmin, generic.ModelFormView):
     def initialize_form(self, form, request, target):
         if request.method == "POST":
             return form(request.POST, request.FILES, instance=target, request=request)
-        else:
-            return form(instance=target, request=request)
+        return form(instance=target, request=request)
 
     def handle_form(self, form, request, target):
         new_user = User.objects.create_user(
@@ -291,8 +290,7 @@ class EditUser(UserAdmin, generic.ModelFormView):
     def initialize_form(self, form, request, target):
         if request.method == "POST":
             return form(request.POST, request.FILES, instance=target, request=request)
-        else:
-            return form(instance=target, request=request)
+        return form(instance=target, request=request)
 
     def handle_form(self, form, request, target):
         target.username = target.old_username