Upgrade to Django 3.2

judge/utils/pwned.py

@@ -40,7 +40,6 @@ import requests
 from django.conf import settings
 from django.contrib.auth.password_validation import CommonPasswordValidator
 from django.core.exceptions import ValidationError
-from django.utils.six import string_types
 from django.utils.translation import gettext as _, ungettext
 
 from judge.utils.unicode import utf8bytes
@@ -83,7 +82,7 @@ def pwned_password(password):
     """
     Checks a password against the Pwned Passwords database.
     """
-    if not isinstance(password, string_types):
+    if not isinstance(password, str):
         raise TypeError("Password values to check must be strings.")
     password_hash = hashlib.sha1(utf8bytes(password)).hexdigest().upper()
     prefix, suffix = password_hash[:5], password_hash[5:]
@@ -107,7 +106,7 @@ class PwnedPasswordsValidator(object):
         error_message = error_message or self.DEFAULT_PWNED_MESSAGE
 
         # If there is no plural, use the same message for both forms.
-        if isinstance(error_message, string_types):
+        if isinstance(error_message, str):
             singular, plural = error_message, error_message
         else:
             singular, plural = error_message

judge/utils/raw_sql.py

@@ -1,40 +1,10 @@
-from copy import copy
-
 from django.db import connections
-from django.db.models import Field
-from django.db.models.expressions import RawSQL
 from django.db.models.sql.constants import INNER, LOUTER
 from django.db.models.sql.datastructures import Join
-from django.utils import six
 
 from judge.utils.cachedict import CacheDict
 
 
-def unique_together_left_join(
-    queryset, model, link_field_name, filter_field_name, filter_value, parent_model=None
-):
-    link_field = copy(model._meta.get_field(link_field_name).remote_field)
-    filter_field = model._meta.get_field(filter_field_name)
-
-    def restrictions(where_class, alias, related_alias):
-        cond = where_class()
-        cond.add(
-            filter_field.get_lookup("exact")(filter_field.get_col(alias), filter_value),
-            "AND",
-        )
-        return cond
-
-    link_field.get_extra_restriction = restrictions
-
-    if parent_model is not None:
-        parent_alias = parent_model._meta.db_table
-    else:
-        parent_alias = queryset.query.get_initial_alias()
-    return queryset.query.join(
-        Join(model._meta.db_table, parent_alias, None, LOUTER, link_field, True)
-    )
-
-
 class RawSQLJoin(Join):
     def __init__(
         self,
@@ -65,8 +35,9 @@ class RawSQLJoin(Join):
 
 
 class FakeJoinField:
-    def __init__(self, joining_columns):
+    def __init__(self, joining_columns, related_model):
         self.joining_columns = joining_columns
+        self.related_model = related_model
 
     def get_joining_columns(self):
         return self.joining_columns
@@ -76,35 +47,36 @@ class FakeJoinField:
 
 
 def join_sql_subquery(
-    queryset, subquery, params, join_fields, alias, join_type=INNER, parent_model=None
+    queryset,
+    subquery,
+    params,
+    join_fields,
+    alias,
+    related_model,
+    join_type=INNER,
+    parent_model=None,
 ):
     if parent_model is not None:
         parent_alias = parent_model._meta.db_table
     else:
         parent_alias = queryset.query.get_initial_alias()
-    queryset.query.external_aliases.add(alias)
+    if isinstance(queryset.query.external_aliases, dict):  # Django 3.x
+        queryset.query.external_aliases[alias] = True
+    else:
+        queryset.query.external_aliases.add(alias)
     join = RawSQLJoin(
         subquery,
         params,
         parent_alias,
         alias,
         join_type,
-        FakeJoinField(join_fields),
+        FakeJoinField(join_fields, related_model),
         join_type == LOUTER,
     )
     queryset.query.join(join)
     join.table_alias = alias
 
 
-def RawSQLColumn(model, field=None):
-    if isinstance(model, Field):
-        field = model
-        model = field.model
-    if isinstance(field, six.string_types):
-        field = model._meta.get_field(field)
-    return RawSQL("%s.%s" % (model._meta.db_table, field.get_attname_column()[1]), ())
-
-
 def make_straight_join_query(QueryType):
     class Query(QueryType):
         def join(self, join, *args, **kwargs):

judge/utils/unicode.py

@@ -1,17 +1,37 @@
-from django.utils import six
+from typing import AnyStr, Optional, overload
+
+
+@overload
+def utf8bytes(maybe_text: AnyStr) -> bytes:
+    pass
+
+
+@overload
+def utf8bytes(maybe_text: None) -> None:
+    pass
 
 
 def utf8bytes(maybe_text):
     if maybe_text is None:
-        return
-    if isinstance(maybe_text, six.binary_type):
+        return None
+    if isinstance(maybe_text, bytes):
         return maybe_text
     return maybe_text.encode("utf-8")
 
 
-def utf8text(maybe_bytes, errors="strict"):
+@overload
+def utf8text(maybe_bytes: AnyStr, errors="strict") -> str:
+    pass
+
+
+@overload
+def utf8text(maybe_bytes: None, errors="strict") -> None:
+    pass
+
+
+def utf8text(maybe_bytes, errors="strict") -> Optional[str]:
     if maybe_bytes is None:
-        return
-    if isinstance(maybe_bytes, six.text_type):
+        return None
+    if isinstance(maybe_bytes, str):
         return maybe_bytes
     return maybe_bytes.decode("utf-8", errors)