class ProfileForm(ModelForm):
     def __init__(self, *args, **kwargs):
         super(ProfileForm, self).__init__(*args, **kwargs)
         if "current_contest" in self.base_fields:
             # form.fields['current_contest'] does not exist when the user has only view permission on the model.
-            self.fields[
-                "current_contest"
-            ].queryset = self.instance.contest_history.select_related("contest").only(
-                "contest__name", "user_id", "virtual"
-            )
-            self.fields["current_contest"].label_from_instance = (
-                lambda obj: "%s v%d" % (obj.contest.name, obj.virtual)
+            self.fields["current_contest"].queryset = (
+                self.instance.contest_history.select_related("contest").only(
+                    "contest__name", "user_id", "virtual"
+                )
+            )
+            self.fields["current_contest"].label_from_instance = lambda obj: (
+                "%s v%d" % (obj.contest.name, obj.virtual)
                 if obj.virtual
                 else obj.contest.name
             )
 
     class Meta:

                 "problem__points",
             )
         )
         for submission in submissions:
             submission.points = round(
-                submission.case_points
-                / submission.case_total
-                * submission.problem.points
-                if submission.case_total
-                else 0,
+                (
+                    submission.case_points
+                    / submission.case_total
+                    * submission.problem.points
+                    if submission.case_total
+                    else 0
+                ),
                 1,
             )
             if (
                 not submission.problem.partial
                 and submission.points < submission.problem.points

 
     def display_participation_result(self, participation, show_final=False):
         return format_html(
             '<td class="user-points">{points}<div class="solving-time">{cumtime}</div></td>',
             points=floatformat(participation.score),
-            cumtime=nice_repr(timedelta(seconds=participation.cumtime), "noday")
-            if self.config["cumtime"]
-            else "",
+            cumtime=(
+                nice_repr(timedelta(seconds=participation.cumtime), "noday")
+                if self.config["cumtime"]
+                else ""
+            ),
         )

                     ],
                 ),
                 points=floatformat(
                     format_data["points"], -self.contest.points_precision
                 ),
-                time=nice_repr(timedelta(seconds=format_data["time"]), "noday")
-                if self.config["cumtime"]
-                else "",
+                time=(
+                    nice_repr(timedelta(seconds=format_data["time"]), "noday")
+                    if self.config["cumtime"]
+                    else ""
+                ),
             )
         else:
             return mark_safe('<td class="problem-score-col"></td>')
 
     def display_participation_result(self, participation, show_final=False):

             score = participation.score
             cumtime = participation.cumtime
         return format_html(
             '<td class="user-points">{points}<div class="solving-time">{cumtime}</div></td>',
             points=floatformat(score, -self.contest.points_precision),
-            cumtime=nice_repr(timedelta(seconds=cumtime), "noday")
-            if self.config["cumtime"]
-            else "",
+            cumtime=(
+                nice_repr(timedelta(seconds=cumtime), "noday")
+                if self.config["cumtime"]
+                else ""
+            ),
         )

                 get_template("problem/raw.html")
                 .render(
                     {
                         "problem": problem,
                         "problem_name": problem_name,
-                        "description": problem.description
-                        if trans is None
-                        else trans.description,
+                        "description": (
+                            problem.description if trans is None else trans.description
+                        ),
                         "url": "",
                     }
                 )
                 .replace('"//', '"https://')
                 .replace("'//", "'https://")

                 "submission-id": submission.id,
                 "problem-id": submission.problem.code,
                 "language": submission.language.key,
                 "source": submission.source.source,
                 "judge-id": judge_id,
-                "priority": BATCH_REJUDGE_PRIORITY
-                if batch_rejudge
-                else REJUDGE_PRIORITY
-                if rejudge
-                else priority,
+                "priority": (
+                    BATCH_REJUDGE_PRIORITY
+                    if batch_rejudge
+                    else REJUDGE_PRIORITY if rejudge else priority
+                ),
             }
         )
     except BaseException:
         logger.exception("Failed to send request to judge")
         Submission.objects.filter(id=submission.id).update(status="IE", result="IE")

         except AttributeError:
             return
 
         contest_problem = contest.problem
         contest.points = round(
-            self.case_points / self.case_total * contest_problem.points
-            if self.case_total > 0
-            else 0,
+            (
+                self.case_points / self.case_total * contest_problem.points
+                if self.case_total > 0
+                else 0
+            ),
             3,
         )
         if not contest_problem.partial and contest.points != contest_problem.points:
             contest.points = 0
         contest.save()

         for participation in participations.iterator():
             for contest_submission in participation.submissions.iterator():
                 submission = contest_submission.submission
                 contest_problem = contest_submission.problem
                 contest_submission.points = round(
-                    submission.case_points
-                    / submission.case_total
-                    * contest_problem.points
-                    if submission.case_total > 0
-                    else 0,
+                    (
+                        submission.case_points
+                        / submission.case_total
+                        * contest_problem.points
+                        if submission.case_total > 0
+                        else 0
+                    ),
                     3,
                 )
                 if (
                     not contest_problem.partial
                     and contest_submission.points != contest_problem.points

 MEAN_INIT = 1400.0
 VAR_INIT = 250**2 * (BETA2 / 212**2)
 SD_INIT = sqrt(VAR_INIT)
 VALID_RANGE = MEAN_INIT - 20 * SD_INIT, MEAN_INIT + 20 * SD_INIT
 VAR_PER_CONTEST = 1219.047619 * (BETA2 / 212**2)
-VAR_LIM = (
-    sqrt(VAR_PER_CONTEST**2 + 4 * BETA2 * VAR_PER_CONTEST) - VAR_PER_CONTEST
-) / 2
+VAR_LIM = (sqrt(VAR_PER_CONTEST**2 + 4 * BETA2 * VAR_PER_CONTEST) - VAR_PER_CONTEST) / 2
 SD_LIM = sqrt(VAR_LIM)
 TANH_C = sqrt(3) / pi
 
 
 def tie_ranker(iterable, key=attrgetter("points")):

         "email": user.email,
         "username": user.username,
         "mute": profile.mute,
         "first_name": user.first_name or None,
         "last_name": user.last_name or None,
-        "profile_image_url": profile.profile_image.url
-        if profile.profile_image
-        else None,
+        "profile_image_url": (
+            profile.profile_image.url if profile.profile_image else None
+        ),
         "display_rank": profile.display_rank,
         "rating": profile.rating,
     }
     res = {k: v for k, v in res.items() if v is not None}
     return res

 
     with Progress(self, submissions.count(), stage=_("Modifying submissions")) as p:
         rescored = 0
         for submission in submissions.iterator():
             submission.points = round(
-                submission.case_points / submission.case_total * problem.points
-                if submission.case_total
-                else 0,
+                (
+                    submission.case_points / submission.case_total * problem.points
+                    if submission.case_total
+                    else 0
+                ),
                 1,
             )
             if not problem.partial and submission.points < problem.points:
                 submission.points = 0
             submission.save(update_fields=["points"])

 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."""
-
 
 import hashlib
 import logging
 
 import requests

                 self.mathoid_url,
                 data={
                     "q": reescape.sub(lambda m: "\\" + m.group(0), formula).encode(
                         "utf-8"
                     ),
-                    "type": "tex"
-                    if formula.startswith(r"\displaystyle")
-                    else "inline-tex",
+                    "type": (
+                        "tex" if formula.startswith(r"\displaystyle") else "inline-tex"
+                    ),
                 },
             )
             response.raise_for_status()
             data = response.json()
         except requests.ConnectionError:

             "rating_ceiling": contest.rating_ceiling,
             "format": {
                 "name": contest.format_name,
                 "config": contest.format_config,
             },
-            "problems": [
-                {
-                    "points": int(problem.points),
-                    "partial": problem.partial,
-                    "name": problem.problem.name,
-                    "code": problem.problem.code,
-                }
-                for problem in problems
-            ]
-            if can_see_problems
-            else [],
+            "problems": (
+                [
+                    {
+                        "points": int(problem.points),
+                        "partial": problem.partial,
+                        "name": problem.problem.name,
+                        "code": problem.problem.code,
+                    }
+                    for problem in problems
+                ]
+                if can_see_problems
+                else []
+            ),
             "rankings": [
                 {
                     "user": participation.username,
                     "points": participation.score,
                     "cumtime": participation.cumtime,

 
         context["current_contests"] = visible_contests.filter(
             start_time__lte=now, end_time__gt=now
         )
         context["future_contests"] = visible_contests.filter(start_time__gt=now)
-        context[
-            "recent_organizations"
-        ] = OrganizationProfile.get_most_recent_organizations(self.request.profile)
+        context["recent_organizations"] = (
+            OrganizationProfile.get_most_recent_organizations(self.request.profile)
+        )
 
         profile_queryset = Profile.objects
         if self.request.organization:
             profile_queryset = self.request.organization.members
         context["top_rated"] = (

                 WHERE sub.problem_id = %s {constraint}
                 GROUP BY sub.user_id
             """.format(
                 points=points, contest_join=contest_join, constraint=constraint
             ),
-            params=[self.problem.id, self.contest.id] * 3
-            if self.in_contest
-            else [self.problem.id] * 3,
+            params=(
+                [self.problem.id, self.contest.id] * 3
+                if self.in_contest
+                else [self.problem.id] * 3
+            ),
             alias="best_subs",
             join_fields=[("id", "id")],
             related_model=Submission,
         )
 

     def post(self, request):
         file_path = request.POST.get("file_path")
 
         with open(file_path, "rb") as zip_file:
             response = HttpResponse(zip_file.read(), content_type="application/zip")
-            response[
-                "Content-Disposition"
-            ] = f"attachment; filename={os.path.basename(file_path)}"
+            response["Content-Disposition"] = (
+                f"attachment; filename={os.path.basename(file_path)}"
+            )
             return response

             lat, long = float(request.GET["lat"]), float(request.GET["long"])
         except (ValueError, KeyError):
             return HttpResponse(
                 _("Bad latitude or longitude"), content_type="text/plain", status=404
             )
-        return {"askgeo": self.askgeo, "geonames": self.geonames,}.get(
+        return {
+            "askgeo": self.askgeo,
+            "geonames": self.geonames,
+        }.get(
             backend, self.default
         )(lat, long)

             template.render(
                 {
                     "original_widget": original,
                     "select_all_id": select_all_id,
                     "select_all_name": select_all_name,
-                    "all_selected": all(choice[0] in value for choice in self.choices)
-                    if value
-                    else False,
+                    "all_selected": (
+                        all(choice[0] in value for choice in self.choices)
+                        if value
+                        else False
+                    ),
                     "empty": not self.choices,
                 }
             )
         )

                 media = super().media
                 template = self.__templates[self.compress_css, self.compress_js]
                 result = html.fromstring(template.render(Context({"media": media})))
 
                 return forms.Media(
-                    css={"all": [result.find(".//link").get("href")]}
-                    if self.compress_css
-                    else media._css,
-                    js=[result.find(".//script").get("src")]
-                    if self.compress_js
-                    else media._js,
+                    css=(
+                        {"all": [result.find(".//link").get("href")]}
+                        if self.compress_css
+                        else media._css
+                    ),
+                    js=(
+                        [result.find(".//script").get("src")]
+                        if self.compress_js
+                        else media._js
+                    ),
                 )

                     get_template("problem/raw.html")
                     .render(
                         {
                             "problem": problem,
                             "problem_name": problem_name,
-                            "description": problem.description
-                            if trans is None
-                            else trans.description,
+                            "description": (
+                                problem.description
+                                if trans is None
+                                else trans.description
+                            ),
                             "url": request.build_absolute_uri(),
                         }
                     )
                     .replace('"//', '"https://')
                     .replace("'//", "'https://")

                 )
         elif sort_key == "type":
             if self.show_types:
                 queryset = list(queryset)
                 queryset.sort(
-                    key=lambda problem: problem.types_list[0]
-                    if problem.types_list
-                    else "",
+                    key=lambda problem: (
+                        problem.types_list[0] if problem.types_list else ""
+                    ),
                     reverse=self.order.startswith("-"),
                 )
         return queryset
 
     @cached_property

             "submission_limit": submission_limit,
             "submissions_left": submissions_left,
             "ACE_URL": settings.ACE_URL,
             "default_lang": default_lang,
             "problem_id": problem.id,
-            "output_only": problem.data_files.output_only
-            if hasattr(problem, "data_files")
-            else False,
+            "output_only": (
+                problem.data_files.output_only
+                if hasattr(problem, "data_files")
+                else False
+            ),
             "next_valid_submit_time": next_valid_submit_time,
         },
     )
 
 

 
     def get_context_data(self, **kwargs):
         context = super(ContestMixin, self).get_context_data(**kwargs)
         if self.request.user.is_authenticated:
             try:
-                context[
-                    "live_participation"
-                ] = self.request.profile.contest_history.get(
-                    contest=self.object,
-                    virtual=ContestParticipation.LIVE,
+                context["live_participation"] = (
+                    self.request.profile.contest_history.get(
+                        contest=self.object,
+                        virtual=ContestParticipation.LIVE,
+                    )
                 )
             except ContestParticipation.DoesNotExist:
                 context["live_participation"] = None
                 context["has_joined"] = False
             else: