diff --git a/allianceauth/groupmanagement/models.py b/allianceauth/groupmanagement/models.py
index e36f7e2d..861872ef 100644
--- a/allianceauth/groupmanagement/models.py
+++ b/allianceauth/groupmanagement/models.py
@@ -55,6 +55,7 @@ class RequestLog(models.Model):
         return user.profile.main_character
 
 
+
 class AuthGroup(models.Model):
     """
     Extends Django Group model with a one-to-one field
@@ -75,75 +76,46 @@ class AuthGroup(models.Model):
         Open - Users are automatically accepted into the group
         Not Open - Users requests must be approved before they are added to the group
     """
-
     group = models.OneToOneField(Group, on_delete=models.CASCADE, primary_key=True)
 
-    internal = models.BooleanField(
-        default=True,
-        help_text="Internal group, users cannot see, join or request to join this group.<br>"
-        "Used for groups such as Members, Corp_*, Alliance_* etc.<br>"
-        "<b>Overrides Hidden and Open options when selected.</b>",
-    )
-
-    hidden = models.BooleanField(
-        default=True,
-        help_text="Group is hidden from users but can still join with the correct link.",
-    )
-
-    open = models.BooleanField(
-        default=False,
-        help_text="Group is open and users will be automatically added upon request. <br>"
-        "If the group is not open users will need their request manually approved.",
-    )
-
-    public = models.BooleanField(
-        default=False,
-        help_text="Group is public. Any registered user is able to join this group, with "
-        "visibility based on the other options set for this group.<br> Auth will "
-        "not remove users from this group automatically when they are no longer "
-        "authenticated.",
-    )
-
+    internal = models.BooleanField(default=True,
+                                   help_text="Internal group, users cannot see, join or request to join this group.<br>"
+                                             "Used for groups such as Members, Corp_*, Alliance_* etc.<br>"
+                                             "<b>Overrides Hidden and Open options when selected.</b>")
+    hidden = models.BooleanField(default=True,
+                                 help_text="Group is hidden from users but can still join with the correct link.")
+    open = models.BooleanField(default=False,
+                               help_text="Group is open and users will be automatically added upon request. <br>"
+                                         "If the group is not open users will need their request manually approved.")
+    public = models.BooleanField(default=False,
+                                 help_text="Group is public. Any registered user is able to join this group, with "
+                                           "visibility based on the other options set for this group.<br> Auth will "
+                                           "not remove users from this group automatically when they are no longer "
+                                           "authenticated.")
     # Group leaders have management access to this group
-    group_leaders = models.ManyToManyField(
-        User,
-        related_name="leads_groups",
-        blank=True,
-        help_text="Group leaders can process group requests for this group "
-        "specifically. Use the auth.group_management permission to allow "
-        "a user to manage all groups.",
-    )
-
+    group_leaders = models.ManyToManyField(User, related_name='leads_groups', blank=True,
+                                           help_text="Group leaders can process group requests for this group "
+                                                     "specifically. Use the auth.group_management permission to allow "
+                                                     "a user to manage all groups.")
     # allow groups to be *group leads*
-    group_leader_groups = models.ManyToManyField(
-        Group,
-        related_name="leads_group_groups",
-        blank=True,
-        help_text="Group leaders can process group requests for this group "
-        "specifically. Use the auth.group_management permission to allow "
-        "a user to manage all groups.",
-    )
+    group_leader_groups = models.ManyToManyField(Group, related_name='leads_group_groups', blank=True,
+                                           help_text="Group leaders can process group requests for this group "
+                                                     "specifically. Use the auth.group_management permission to allow "
+                                                     "a user to manage all groups.")
 
-    states = models.ManyToManyField(
-        State,
-        related_name="valid_states",
-        blank=True,
-        help_text="States listed here will have the ability to join this group provided "
-        "they have the proper permissions.",
-    )
+    states = models.ManyToManyField(State, related_name='valid_states', blank=True,
+                                    help_text="States listed here will have the ability to join this group provided "
+                                              "they have the proper permissions.")
 
-    description = models.TextField(
-        max_length=512,
-        null=True,
-        blank=True,
-        help_text="Short description <i>(max. 512 characters)</i> of the group shown to users.",
-    )
+    description = models.TextField(max_length=512, blank=True, help_text="Short description <i>(max. 512 characters)</i> of the group shown to users.")
 
     def __str__(self):
         return self.group.name
 
     class Meta:
-        permissions = (("request_groups", u"Can request non-public groups"),)
+        permissions = (
+            ("request_groups", u"Can request non-public groups"),
+        )
         default_permissions = tuple()
 
 
diff --git a/allianceauth/groupmanagement/views.py b/allianceauth/groupmanagement/views.py
index 55956f7b..4e6e27ff 100755
--- a/allianceauth/groupmanagement/views.py
+++ b/allianceauth/groupmanagement/views.py
@@ -27,9 +27,7 @@ def group_management(request):
     acceptrequests = []
     leaverequests = []
 
-    base_group_query = GroupRequest.objects.select_related(
-        "user", "group", "user__profile__main_character"
-    )
+    base_group_query = GroupRequest.objects.select_related('user', 'group', 'user__profile__main_character')
     if GroupManager.has_management_permission(request.user):
         # Full access
         group_requests = base_group_query.all()
@@ -44,14 +42,12 @@ def group_management(request):
         else:
             acceptrequests.append(grouprequest)
 
-    logger.debug(
-        "Providing user %s with %s acceptrequests and %s leaverequests."
-        % (request.user, len(acceptrequests), len(leaverequests))
-    )
+    logger.debug("Providing user %s with %s acceptrequests and %s leaverequests." % (
+        request.user, len(acceptrequests), len(leaverequests)))
 
-    render_items = {"acceptrequests": acceptrequests, "leaverequests": leaverequests}
+    render_items = {'acceptrequests': acceptrequests, 'leaverequests': leaverequests}
 
-    return render(request, "groupmanagement/index.html", context=render_items)
+    return render(request, 'groupmanagement/index.html', context=render_items)
 
 
 @login_required
@@ -66,15 +62,11 @@ def group_membership(request):
         # Group leader specific
         groups = GroupManager.get_group_leaders_groups(request.user)
 
-    groups = (
-        groups.exclude(authgroup__internal=True)
-        .annotate(num_members=Count("user"))
-        .order_by("name")
-    )
+    groups = groups.exclude(authgroup__internal=True).annotate(num_members=Count('user')).order_by('name')
 
-    render_items = {"groups": groups}
+    render_items = {'groups': groups}
 
-    return render(request, "groupmanagement/groupmembership.html", context=render_items)
+    return render(request, 'groupmanagement/groupmembership.html', context=render_items)
 
 
 @login_required
@@ -85,22 +77,18 @@ def group_membership_audit(request, group_id):
     try:
         # Check its a joinable group i.e. not corp or internal
         # And the user has permission to manage it
-        if not GroupManager.check_internal_group(
-            group
-        ) or not GroupManager.can_manage_group(request.user, group):
-            logger.warning(
-                "User %s attempted to view the membership of group %s but permission was denied"
-                % (request.user, group_id)
-            )
+        if not GroupManager.check_internal_group(group) or not GroupManager.can_manage_group(request.user, group):
+            logger.warning("User %s attempted to view the membership of group %s but permission was denied" %
+                           (request.user, group_id))
             raise PermissionDenied
 
     except ObjectDoesNotExist:
         raise Http404("Group does not exist")
-    render_items = {"group": group.name}
-    entries = RequestLog.objects.filter(group=group).order_by("-date")
-    render_items["entries"] = entries
+    render_items = {'group': group.name}
+    entries = RequestLog.objects.filter(group=group).order_by('-date')
+    render_items['entries'] = entries
 
-    return render(request, "groupmanagement/audit.html", context=render_items)
+    return render(request, 'groupmanagement/audit.html', context=render_items)
 
 
 @login_required
@@ -115,9 +103,9 @@ def group_membership_list(request, group_id):
 
         # Check its a joinable group i.e. not corp or internal
         # And the user has permission to manage it
-        if not GroupManager.check_internal_group(
-            group
-        ) or not GroupManager.can_manage_group(request.user, group):
+        if (not GroupManager.check_internal_group(group)
+            or not GroupManager.can_manage_group(request.user, group)
+        ):
             logger.warning(
                 "User %s attempted to view the membership of group %s "
                 "but permission was denied" % (request.user, group_id)
@@ -129,136 +117,90 @@ def group_membership_list(request, group_id):
 
     group_leaders = group.authgroup.group_leaders.all()
     members = list()
-    for member in (
-        group.user_set.all()
-        .select_related("profile", "profile__main_character")
-        .order_by("profile__main_character__character_name")
-    ):
+    for member in \
+        group.user_set\
+            .all()\
+            .select_related('profile', 'profile__main_character')\
+            .order_by('profile__main_character__character_name'):
 
-        members.append(
-            {
-                "user": member,
-                "main_char": member.profile.main_character,
-                "is_leader": member in group_leaders,
-            }
-        )
+        members.append({
+            'user': member,
+            'main_char': member.profile.main_character,
+            'is_leader': member in group_leaders
+        })
 
-    render_items = {"group": group, "members": members}
+    render_items = {'group': group, 'members': members}
 
-    return render(request, "groupmanagement/groupmembers.html", context=render_items)
+    return render(
+        request, 'groupmanagement/groupmembers.html',
+        context=render_items
+    )
 
 
 @login_required
 @user_passes_test(GroupManager.can_manage_groups)
 def group_membership_remove(request, group_id, user_id):
-    logger.debug(
-        "group_membership_remove called by user %s for group id %s on user id %s"
-        % (request.user, group_id, user_id)
-    )
+    logger.debug("group_membership_remove called by user %s for group id %s on user id %s" %
+                 (request.user, group_id, user_id))
     group = get_object_or_404(Group, id=group_id)
     try:
         # Check its a joinable group i.e. not corp or internal
         # And the user has permission to manage it
-        if not GroupManager.check_internal_group(
-            group
-        ) or not GroupManager.can_manage_group(request.user, group):
-            logger.warning(
-                "User %s attempted to remove a user from group %s but permission was denied"
-                % (request.user, group_id)
-            )
+        if not GroupManager.check_internal_group(group) or not GroupManager.can_manage_group(request.user, group):
+            logger.warning("User %s attempted to remove a user from group %s but permission was denied" % (request.user,
+                                                                                                           group_id))
             raise PermissionDenied
 
         try:
             user = group.user_set.get(id=user_id)
             request_info = user.username + ":" + group.name
-            log = RequestLog(
-                request_type=None,
-                group=group,
-                request_info=request_info,
-                action=1,
-                request_actor=request.user,
-            )
+            log = RequestLog(request_type=None,group=group,request_info=request_info,action=1,request_actor=request.user)
             log.save()
             # Remove group from user
             user.groups.remove(group)
-            logger.info(
-                "User %s removed user %s from group %s" % (request.user, user, group)
-            )
-            messages.success(
-                request,
-                _("Removed user %(user)s from group %(group)s.")
-                % {"user": user, "group": group},
-            )
+            logger.info("User %s removed user %s from group %s" % (request.user, user, group))
+            messages.success(request, _("Removed user %(user)s from group %(group)s.") % {"user": user, "group": group})
         except ObjectDoesNotExist:
             messages.warning(request, _("User does not exist in that group"))
 
     except ObjectDoesNotExist:
         messages.warning(request, _("Group does not exist"))
 
-    return redirect("groupmanagement:membership", group_id)
+    return redirect('groupmanagement:membership', group_id)
 
 
 @login_required
 @user_passes_test(GroupManager.can_manage_groups)
 def group_accept_request(request, group_request_id):
-    logger.debug(
-        "group_accept_request called by user %s for grouprequest id %s"
-        % (request.user, group_request_id)
-    )
+    logger.debug("group_accept_request called by user %s for grouprequest id %s" % (request.user, group_request_id))
     group_request = get_object_or_404(GroupRequest, id=group_request_id)
     try:
         group, created = Group.objects.get_or_create(name=group_request.group.name)
 
-        if not GroupManager.joinable_group(
-            group_request.group, group_request.user.profile.state
-        ) or not GroupManager.can_manage_group(request.user, group_request.group):
+        if not GroupManager.joinable_group(group_request.group, group_request.user.profile.state) or \
+                not GroupManager.can_manage_group(request.user, group_request.group):
             raise PermissionDenied
 
         group_request.user.groups.add(group)
         group_request.user.save()
-        log = RequestLog(
-            request_type=group_request.leave_request,
-            group=group,
-            request_info=group_request.__str__(),
-            action=1,
-            request_actor=request.user,
-        )
+        log = RequestLog(request_type=group_request.leave_request,group=group,request_info=group_request.__str__(),action=1,request_actor=request.user)
         log.save()
         group_request.delete()
-        logger.info(
-            "User %s accepted group request from user %s to group %s"
-            % (request.user, group_request.user, group_request.group.name)
-        )
-        notify(
-            group_request.user,
-            "Group Application Accepted",
-            level="success",
-            message="Your application to %s has been accepted." % group_request.group,
-        )
-        messages.success(
-            request,
-            _("Accepted application from %(mainchar)s to %(group)s.")
-            % {"mainchar": group_request.main_char, "group": group_request.group},
-        )
+        logger.info("User %s accepted group request from user %s to group %s" % (
+            request.user, group_request.user, group_request.group.name))
+        notify(group_request.user, "Group Application Accepted", level="success",
+               message="Your application to %s has been accepted." % group_request.group)
+        messages.success(request,
+                         _('Accepted application from %(mainchar)s to %(group)s.') % {"mainchar": group_request.main_char, "group": group_request.group})
 
     except PermissionDenied as p:
-        logger.warning(
-            "User %s attempted to accept group join request %s but permission was denied"
-            % (request.user, group_request_id)
-        )
+        logger.warning("User %s attempted to accept group join request %s but permission was denied" %
+                       (request.user, group_request_id))
         raise p
     except:
-        messages.error(
-            request,
-            _(
-                "An unhandled error occurred while processing the application from %(mainchar)s to %(group)s."
-            )
-            % {"mainchar": group_request.main_char, "group": group_request.group},
-        )
-        logger.exception(
-            "Unhandled exception occurred while user %s attempting to accept grouprequest id %s."
-            % (request.user, group_request_id)
-        )
+        messages.error(request, _('An unhandled error occurred while processing the application from %(mainchar)s to %(group)s.') % {"mainchar": group_request.main_char, "group": group_request.group})
+        logger.exception("Unhandled exception occurred while user %s attempting to accept grouprequest id %s." % (
+            request.user, group_request_id))
         pass
 
     return redirect("groupmanagement:management")
@@ -267,60 +209,31 @@ def group_accept_request(request, group_request_id):
 @login_required
 @user_passes_test(GroupManager.can_manage_groups)
 def group_reject_request(request, group_request_id):
-    logger.debug(
-        "group_reject_request called by user %s for group request id %s"
-        % (request.user, group_request_id)
-    )
+    logger.debug("group_reject_request called by user %s for group request id %s" % (request.user, group_request_id))
     group_request = get_object_or_404(GroupRequest, id=group_request_id)
     try:
         if not GroupManager.can_manage_group(request.user, group_request.group):
             raise PermissionDenied
 
         if group_request:
-            logger.info(
-                "User %s rejected group request from user %s to group %s"
-                % (request.user, group_request.user, group_request.group.name)
-            )
-            log = RequestLog(
-                request_type=group_request.leave_request,
-                group=group_request.group,
-                request_info=group_request.__str__(),
-                action=0,
-                request_actor=request.user,
-            )
+            logger.info("User %s rejected group request from user %s to group %s" % (
+                request.user, group_request.user, group_request.group.name))
+            log = RequestLog(request_type=group_request.leave_request,group=group_request.group,request_info=group_request.__str__(),action=0,request_actor=request.user)
             log.save()
             group_request.delete()
-            notify(
-                group_request.user,
-                "Group Application Rejected",
-                level="danger",
-                message="Your application to %s has been rejected."
-                % group_request.group,
-            )
-            messages.success(
-                request,
-                _("Rejected application from %(mainchar)s to %(group)s.")
-                % {"mainchar": group_request.main_char, "group": group_request.group},
-            )
+            notify(group_request.user, "Group Application Rejected", level="danger",
+                   message="Your application to %s has been rejected." % group_request.group)
+            messages.success(request,
+                             _('Rejected application from %(mainchar)s to %(group)s.') % {"mainchar": group_request.main_char, "group": group_request.group})
 
     except PermissionDenied as p:
-        logger.warning(
-            "User %s attempted to reject group join request %s but permission was denied"
-            % (request.user, group_request_id)
-        )
+        logger.warning("User %s attempted to reject group join request %s but permission was denied" %
+                       (request.user, group_request_id))
         raise p
     except:
-        messages.error(
-            request,
-            _(
-                "An unhandled error occurred while processing the application from %(mainchar)s to %(group)s."
-            )
-            % {"mainchar": group_request.main_char, "group": group_request.group},
-        )
-        logger.exception(
-            "Unhandled exception occurred while user %s attempting to reject group request id %s"
-            % (request.user, group_request_id)
-        )
+        messages.error(request, _('An unhandled error occurred while processing the application from %(mainchar)s to %(group)s.') % {"mainchar": group_request.main_char, "group": group_request.group})
+        logger.exception("Unhandled exception occurred while user %s attempting to reject group request id %s" % (
+            request.user, group_request_id))
         pass
 
     return redirect("groupmanagement:management")
@@ -330,9 +243,7 @@ def group_reject_request(request, group_request_id):
 @user_passes_test(GroupManager.can_manage_groups)
 def group_leave_accept_request(request, group_request_id):
     logger.debug(
-        "group_leave_accept_request called by user %s for group request id %s"
-        % (request.user, group_request_id)
-    )
+        "group_leave_accept_request called by user %s for group request id %s" % (request.user, group_request_id))
     group_request = get_object_or_404(GroupRequest, id=group_request_id)
     try:
         if not GroupManager.can_manage_group(request.user, group_request.group):
@@ -341,48 +252,24 @@ def group_leave_accept_request(request, group_request_id):
         group, created = Group.objects.get_or_create(name=group_request.group.name)
         group_request.user.groups.remove(group)
         group_request.user.save()
-        log = RequestLog(
-            request_type=group_request.leave_request,
-            group=group_request.group,
-            request_info=group_request.__str__(),
-            action=1,
-            request_actor=request.user,
-        )
+        log = RequestLog(request_type=group_request.leave_request,group=group_request.group,request_info=group_request.__str__(),action=1,request_actor=request.user)
         log.save()
         group_request.delete()
-        logger.info(
-            "User %s accepted group leave request from user %s to group %s"
-            % (request.user, group_request.user, group_request.group.name)
-        )
-        notify(
-            group_request.user,
-            "Group Leave Request Accepted",
-            level="success",
-            message="Your request to leave %s has been accepted." % group_request.group,
-        )
-        messages.success(
-            request,
-            _("Accepted application from %(mainchar)s to leave %(group)s.")
-            % {"mainchar": group_request.main_char, "group": group_request.group},
-        )
+        logger.info("User %s accepted group leave request from user %s to group %s" % (
+            request.user, group_request.user, group_request.group.name))
+        notify(group_request.user, "Group Leave Request Accepted", level="success",
+               message="Your request to leave %s has been accepted." % group_request.group)
+        messages.success(request,
+                         _('Accepted application from %(mainchar)s to leave %(group)s.') % {"mainchar": group_request.main_char, "group": group_request.group})
     except PermissionDenied as p:
-        logger.warning(
-            "User %s attempted to accept group leave request %s but permission was denied"
-            % (request.user, group_request_id)
-        )
+        logger.warning("User %s attempted to accept group leave request %s but permission was denied" %
+                       (request.user, group_request_id))
         raise p
     except:
-        messages.error(
-            request,
-            _(
-                "An unhandled error occurred while processing the application from %(mainchar)s to leave %(group)s."
-            )
-            % {"mainchar": group_request.main_char, "group": group_request.group},
-        )
-        logger.exception(
-            "Unhandled exception occurred while user %s attempting to accept group leave request id %s"
-            % (request.user, group_request_id)
-        )
+        messages.error(request, _('An unhandled error occurred while processing the application from %(mainchar)s to leave %(group)s.') % {
+            "mainchar": group_request.main_char, "group": group_request.group})
+        logger.exception("Unhandled exception occurred while user %s attempting to accept group leave request id %s" % (
+            request.user, group_request_id))
         pass
 
     return redirect("groupmanagement:management")
@@ -392,58 +279,31 @@ def group_leave_accept_request(request, group_request_id):
 @user_passes_test(GroupManager.can_manage_groups)
 def group_leave_reject_request(request, group_request_id):
     logger.debug(
-        "group_leave_reject_request called by user %s for group request id %s"
-        % (request.user, group_request_id)
-    )
+        "group_leave_reject_request called by user %s for group request id %s" % (request.user, group_request_id))
     group_request = get_object_or_404(GroupRequest, id=group_request_id)
     try:
         if not GroupManager.can_manage_group(request.user, group_request.group):
             raise PermissionDenied
 
         if group_request:
-            log = RequestLog(
-                request_type=group_request.leave_request,
-                group=group_request.group,
-                request_info=group_request.__str__(),
-                action=0,
-                request_actor=request.user,
-            )
+            log = RequestLog(request_type=group_request.leave_request,group=group_request.group,request_info=group_request.__str__(),action=0,request_actor=request.user)
             log.save()
             group_request.delete()
-            logger.info(
-                "User %s rejected group leave request from user %s for group %s"
-                % (request.user, group_request.user, group_request.group.name)
-            )
-            notify(
-                group_request.user,
-                "Group Leave Request Rejected",
-                level="danger",
-                message="Your request to leave %s has been rejected."
-                % group_request.group,
-            )
-            messages.success(
-                request,
-                _("Rejected application from %(mainchar)s to leave %(group)s.")
-                % {"mainchar": group_request.main_char, "group": group_request.group},
-            )
+            logger.info("User %s rejected group leave request from user %s for group %s" % (
+                request.user, group_request.user, group_request.group.name))
+            notify(group_request.user, "Group Leave Request Rejected", level="danger",
+                   message="Your request to leave %s has been rejected." % group_request.group)
+            messages.success(request, _('Rejected application from %(mainchar)s to leave %(group)s.') % {
+                "mainchar": group_request.main_char, "group": group_request.group})
     except PermissionDenied as p:
-        logger.warning(
-            "User %s attempted to reject group leave request %s but permission was denied"
-            % (request.user, group_request_id)
-        )
+        logger.warning("User %s attempted to reject group leave request %s but permission was denied" %
+                       (request.user, group_request_id))
         raise p
     except:
-        messages.error(
-            request,
-            _(
-                "An unhandled error occurred while processing the application from %(mainchar)s to leave %(group)s."
-            )
-            % {"mainchar": group_request.main_char, "group": group_request.group},
-        )
-        logger.exception(
-            "Unhandled exception occurred while user %s attempting to reject group leave request id %s"
-            % (request.user, group_request_id)
-        )
+        messages.error(request, _('An unhandled error occurred while processing the application from %(mainchar)s to leave %(group)s.') % {
+            "mainchar": group_request.main_char, "group": group_request.group})
+        logger.exception("Unhandled exception occurred while user %s attempting to reject group leave request id %s" % (
+            request.user, group_request_id))
         pass
 
     return redirect("groupmanagement:management")
@@ -456,131 +316,96 @@ def groups_view(request):
     groups_qs = GroupManager.get_joinable_groups_for_user(
         request.user, include_hidden=False
     )
-    groups_qs = groups_qs.order_by("name")
+    groups_qs = groups_qs.order_by('name')
     groups = []
     for group in groups_qs:
-        group_request = GroupRequest.objects.filter(user=request.user).filter(
-            group=group
-        )
-        groups.append(
-            {"group": group, "request": group_request[0] if group_request else None}
-        )
+        group_request = GroupRequest.objects\
+            .filter(user=request.user)\
+            .filter(group=group)
+        groups.append({
+            'group': group,
+            'request': group_request[0] if group_request else None
+        })
 
-    context = {"groups": groups}
-    return render(request, "groupmanagement/groups.html", context=context)
+    context = {'groups': groups}
+    return render(request, 'groupmanagement/groups.html', context=context)
 
 
 @login_required
 def group_request_add(request, group_id):
-    logger.debug(
-        "group_request_add called by user %s for group id %s" % (request.user, group_id)
-    )
+    logger.debug("group_request_add called by user %s for group id %s" % (request.user, group_id))
     group = Group.objects.get(id=group_id)
     state = request.user.profile.state
     if not GroupManager.joinable_group(group, state):
-        logger.warning(
-            "User %s attempted to join group id %s but it is not a joinable group"
-            % (request.user, group_id)
-        )
+        logger.warning("User %s attempted to join group id %s but it is not a joinable group" %
+                       (request.user, group_id))
         messages.warning(request, _("You cannot join that group"))
-        return redirect("groupmanagement:groups")
+        return redirect('groupmanagement:groups')
     if group in request.user.groups.all():
         # User is already a member of this group.
-        logger.warning(
-            "User %s attempted to join group id %s but they are already a member."
-            % (request.user, group_id)
-        )
+        logger.warning("User %s attempted to join group id %s but they are already a member." %
+                       (request.user, group_id))
         messages.warning(request, _("You are already a member of that group."))
-        return redirect("groupmanagement:groups")
-    if (
-        not request.user.has_perm("groupmanagement.request_groups")
-        and not group.authgroup.public
-    ):
+        return redirect('groupmanagement:groups')
+    if not request.user.has_perm('groupmanagement.request_groups') and not group.authgroup.public:
         # Does not have the required permission, trying to join a non-public group
-        logger.warning(
-            "User %s attempted to join group id %s but it is not a public group"
-            % (request.user, group_id)
-        )
+        logger.warning("User %s attempted to join group id %s but it is not a public group" %
+                       (request.user, group_id))
         messages.warning(request, _("You cannot join that group"))
-        return redirect("groupmanagement:groups")
+        return redirect('groupmanagement:groups')
     if group.authgroup.open:
         logger.info("%s joining %s as is an open group" % (request.user, group))
         request.user.groups.add(group)
         return redirect("groupmanagement:groups")
     req = GroupRequest.objects.filter(user=request.user, group=group)
     if len(req) > 0:
-        logger.info(
-            "%s attempted to join %s but already has an open application"
-            % (request.user, group)
-        )
-        messages.warning(
-            request, _("You already have a pending application for that group.")
-        )
+        logger.info("%s attempted to join %s but already has an open application" % (request.user, group))
+        messages.warning(request, _("You already have a pending application for that group."))
         return redirect("groupmanagement:groups")
     grouprequest = GroupRequest()
-    grouprequest.status = _("Pending")
+    grouprequest.status = _('Pending')
     grouprequest.group = group
     grouprequest.user = request.user
     grouprequest.leave_request = False
     grouprequest.save()
-    logger.info(
-        "Created group request for user %s to group %s"
-        % (request.user, Group.objects.get(id=group_id))
-    )
-    messages.success(request, _("Applied to group %(group)s.") % {"group": group})
+    logger.info("Created group request for user %s to group %s" % (request.user, Group.objects.get(id=group_id)))
+    messages.success(request, _('Applied to group %(group)s.') % {"group": group})
     return redirect("groupmanagement:groups")
 
 
 @login_required
 def group_request_leave(request, group_id):
-    logger.debug(
-        "group_request_leave called by user %s for group id %s"
-        % (request.user, group_id)
-    )
+    logger.debug("group_request_leave called by user %s for group id %s" % (request.user, group_id))
     group = Group.objects.get(id=group_id)
     if not GroupManager.check_internal_group(group):
-        logger.warning(
-            "User %s attempted to leave group id %s but it is not a joinable group"
-            % (request.user, group_id)
-        )
+        logger.warning("User %s attempted to leave group id %s but it is not a joinable group" %
+                       (request.user, group_id))
         messages.warning(request, _("You cannot leave that group"))
-        return redirect("groupmanagement:groups")
+        return redirect('groupmanagement:groups')
     if group not in request.user.groups.all():
-        logger.debug(
-            "User %s attempted to leave group id %s but they are not a member"
-            % (request.user, group_id)
-        )
+        logger.debug("User %s attempted to leave group id %s but they are not a member" %
+                     (request.user, group_id))
         messages.warning(request, _("You are not a member of that group"))
-        return redirect("groupmanagement:groups")
+        return redirect('groupmanagement:groups')
     if group.authgroup.open:
         logger.info("%s leaving %s as is an open group" % (request.user, group))
         request.user.groups.remove(group)
         return redirect("groupmanagement:groups")
     req = GroupRequest.objects.filter(user=request.user, group=group)
     if len(req) > 0:
-        logger.info(
-            "%s attempted to leave %s but already has an pending leave request."
-            % (request.user, group)
-        )
-        messages.warning(
-            request, _("You already have a pending leave request for that group.")
-        )
+        logger.info("%s attempted to leave %s but already has an pending leave request." % (request.user, group))
+        messages.warning(request, _("You already have a pending leave request for that group."))
         return redirect("groupmanagement:groups")
-    if getattr(settings, "AUTO_LEAVE", False):
-        logger.info(
-            "%s leaving joinable group %s due to auto_leave" % (request.user, group)
-        )
+    if getattr(settings, 'AUTO_LEAVE', False):
+        logger.info("%s leaving joinable group %s due to auto_leave" % (request.user, group))
         request.user.groups.remove(group)
-        return redirect("groupmanagement:groups")
+        return redirect('groupmanagement:groups')
     grouprequest = GroupRequest()
-    grouprequest.status = _("Pending")
+    grouprequest.status = _('Pending')
     grouprequest.group = group
     grouprequest.user = request.user
     grouprequest.leave_request = True
     grouprequest.save()
-    logger.info(
-        "Created group leave request for user %s to group %s"
-        % (request.user, Group.objects.get(id=group_id))
-    )
-    messages.success(request, _("Applied to leave group %(group)s.") % {"group": group})
+    logger.info("Created group leave request for user %s to group %s" % (request.user, Group.objects.get(id=group_id)))
+    messages.success(request, _('Applied to leave group %(group)s.') % {"group": group})
     return redirect("groupmanagement:groups")