일단 커밋. 오랫동안 커밋을 안해서 꼬였다.

리팩토리 중.

.venv/lib/python3.12/site-packages/django/test/__init__.py

@@ -0,0 +1,38 @@
+"""Django Unit Test framework."""
+
+from django.test.client import AsyncClient, AsyncRequestFactory, Client, RequestFactory
+from django.test.testcases import (
+    LiveServerTestCase,
+    SimpleTestCase,
+    TestCase,
+    TransactionTestCase,
+    skipIfDBFeature,
+    skipUnlessAnyDBFeature,
+    skipUnlessDBFeature,
+)
+from django.test.utils import (
+    ignore_warnings,
+    modify_settings,
+    override_settings,
+    override_system_checks,
+    tag,
+)
+
+__all__ = [
+    "AsyncClient",
+    "AsyncRequestFactory",
+    "Client",
+    "RequestFactory",
+    "TestCase",
+    "TransactionTestCase",
+    "SimpleTestCase",
+    "LiveServerTestCase",
+    "skipIfDBFeature",
+    "skipUnlessAnyDBFeature",
+    "skipUnlessDBFeature",
+    "ignore_warnings",
+    "modify_settings",
+    "override_settings",
+    "override_system_checks",
+    "tag",
+]

.venv/lib/python3.12/site-packages/django/test/html.py

@@ -0,0 +1,273 @@
+"""Compare two HTML documents."""
+
+import html
+from html.parser import HTMLParser
+
+from django.utils.html import VOID_ELEMENTS
+from django.utils.regex_helper import _lazy_re_compile
+
+# ASCII whitespace is U+0009 TAB, U+000A LF, U+000C FF, U+000D CR, or U+0020
+# SPACE.
+# https://infra.spec.whatwg.org/#ascii-whitespace
+ASCII_WHITESPACE = _lazy_re_compile(r"[\t\n\f\r ]+")
+
+# https://html.spec.whatwg.org/#attributes-3
+BOOLEAN_ATTRIBUTES = {
+    "allowfullscreen",
+    "async",
+    "autofocus",
+    "autoplay",
+    "checked",
+    "controls",
+    "default",
+    "defer ",
+    "disabled",
+    "formnovalidate",
+    "hidden",
+    "ismap",
+    "itemscope",
+    "loop",
+    "multiple",
+    "muted",
+    "nomodule",
+    "novalidate",
+    "open",
+    "playsinline",
+    "readonly",
+    "required",
+    "reversed",
+    "selected",
+    # Attributes for deprecated tags.
+    "truespeed",
+}
+
+
+def normalize_whitespace(string):
+    return ASCII_WHITESPACE.sub(" ", string)
+
+
+def normalize_attributes(attributes):
+    normalized = []
+    for name, value in attributes:
+        if name == "class" and value:
+            # Special case handling of 'class' attribute, so that comparisons
+            # of DOM instances are not sensitive to ordering of classes.
+            value = " ".join(
+                sorted(value for value in ASCII_WHITESPACE.split(value) if value)
+            )
+        # Boolean attributes without a value is same as attribute with value
+        # that equals the attributes name. For example:
+        #   <input checked> == <input checked="checked">
+        if name in BOOLEAN_ATTRIBUTES:
+            if not value or value == name:
+                value = None
+        elif value is None:
+            value = ""
+        normalized.append((name, value))
+    return normalized
+
+
+class Element:
+    def __init__(self, name, attributes):
+        self.name = name
+        self.attributes = sorted(attributes)
+        self.children = []
+
+    def append(self, element):
+        if isinstance(element, str):
+            element = normalize_whitespace(element)
+            if self.children and isinstance(self.children[-1], str):
+                self.children[-1] += element
+                self.children[-1] = normalize_whitespace(self.children[-1])
+                return
+        elif self.children:
+            # removing last children if it is only whitespace
+            # this can result in incorrect dom representations since
+            # whitespace between inline tags like <span> is significant
+            if isinstance(self.children[-1], str) and self.children[-1].isspace():
+                self.children.pop()
+        if element:
+            self.children.append(element)
+
+    def finalize(self):
+        def rstrip_last_element(children):
+            if children and isinstance(children[-1], str):
+                children[-1] = children[-1].rstrip()
+                if not children[-1]:
+                    children.pop()
+                    children = rstrip_last_element(children)
+            return children
+
+        rstrip_last_element(self.children)
+        for i, child in enumerate(self.children):
+            if isinstance(child, str):
+                self.children[i] = child.strip()
+            elif hasattr(child, "finalize"):
+                child.finalize()
+
+    def __eq__(self, element):
+        if not hasattr(element, "name") or self.name != element.name:
+            return False
+        if self.attributes != element.attributes:
+            return False
+        return self.children == element.children
+
+    def __hash__(self):
+        return hash((self.name, *self.attributes))
+
+    def _count(self, element, count=True):
+        if not isinstance(element, str) and self == element:
+            return 1
+        if isinstance(element, RootElement) and self.children == element.children:
+            return 1
+        i = 0
+        elem_child_idx = 0
+        for child in self.children:
+            # child is text content and element is also text content, then
+            # make a simple "text" in "text"
+            if isinstance(child, str):
+                if isinstance(element, str):
+                    if count:
+                        i += child.count(element)
+                    elif element in child:
+                        return 1
+            else:
+                # Look for element wholly within this child.
+                i += child._count(element, count=count)
+                if not count and i:
+                    return i
+                # Also look for a sequence of element's children among self's
+                # children. self.children == element.children is tested above,
+                # but will fail if self has additional children. Ex: '<a/><b/>'
+                # is contained in '<a/><b/><c/>'.
+                if isinstance(element, RootElement) and element.children:
+                    elem_child = element.children[elem_child_idx]
+                    # Start or continue match, advance index.
+                    if elem_child == child:
+                        elem_child_idx += 1
+                        # Match found, reset index.
+                        if elem_child_idx == len(element.children):
+                            i += 1
+                            elem_child_idx = 0
+                    # No match, reset index.
+                    else:
+                        elem_child_idx = 0
+        return i
+
+    def __contains__(self, element):
+        return self._count(element, count=False) > 0
+
+    def count(self, element):
+        return self._count(element, count=True)
+
+    def __getitem__(self, key):
+        return self.children[key]
+
+    def __str__(self):
+        output = "<%s" % self.name
+        for key, value in self.attributes:
+            if value is not None:
+                output += ' %s="%s"' % (key, value)
+            else:
+                output += " %s" % key
+        if self.children:
+            output += ">\n"
+            output += "".join(
+                [
+                    html.escape(c) if isinstance(c, str) else str(c)
+                    for c in self.children
+                ]
+            )
+            output += "\n</%s>" % self.name
+        else:
+            output += ">"
+        return output
+
+    def __repr__(self):
+        return str(self)
+
+
+class RootElement(Element):
+    def __init__(self):
+        super().__init__(None, ())
+
+    def __str__(self):
+        return "".join(
+            [html.escape(c) if isinstance(c, str) else str(c) for c in self.children]
+        )
+
+
+class HTMLParseError(Exception):
+    pass
+
+
+class Parser(HTMLParser):
+    def __init__(self):
+        super().__init__()
+        self.root = RootElement()
+        self.open_tags = []
+        self.element_positions = {}
+
+    def error(self, msg):
+        raise HTMLParseError(msg, self.getpos())
+
+    def format_position(self, position=None, element=None):
+        if not position and element:
+            position = self.element_positions[element]
+        if position is None:
+            position = self.getpos()
+        if hasattr(position, "lineno"):
+            position = position.lineno, position.offset
+        return "Line %d, Column %d" % position
+
+    @property
+    def current(self):
+        if self.open_tags:
+            return self.open_tags[-1]
+        else:
+            return self.root
+
+    def handle_startendtag(self, tag, attrs):
+        self.handle_starttag(tag, attrs)
+        if tag not in VOID_ELEMENTS:
+            self.handle_endtag(tag)
+
+    def handle_starttag(self, tag, attrs):
+        attrs = normalize_attributes(attrs)
+        element = Element(tag, attrs)
+        self.current.append(element)
+        if tag not in VOID_ELEMENTS:
+            self.open_tags.append(element)
+        self.element_positions[element] = self.getpos()
+
+    def handle_endtag(self, tag):
+        if not self.open_tags:
+            self.error("Unexpected end tag `%s` (%s)" % (tag, self.format_position()))
+        element = self.open_tags.pop()
+        while element.name != tag:
+            if not self.open_tags:
+                self.error(
+                    "Unexpected end tag `%s` (%s)" % (tag, self.format_position())
+                )
+            element = self.open_tags.pop()
+
+    def handle_data(self, data):
+        self.current.append(data)
+
+
+def parse_html(html):
+    """
+    Take a string that contains HTML and turn it into a Python object structure
+    that can be easily compared against other HTML on semantic equivalence.
+    Syntactical differences like which quotation is used on arguments will be
+    ignored.
+    """
+    parser = Parser()
+    parser.feed(html)
+    parser.close()
+    document = parser.root
+    document.finalize()
+    # Removing ROOT element if it's not necessary
+    if len(document.children) == 1 and not isinstance(document.children[0], str):
+        document = document.children[0]
+    return document

.venv/lib/python3.12/site-packages/django/test/selenium.py

@@ -0,0 +1,263 @@
+import sys
+import unittest
+from contextlib import contextmanager
+from functools import wraps
+from pathlib import Path
+
+from django.conf import settings
+from django.test import LiveServerTestCase, override_settings, tag
+from django.utils.functional import classproperty
+from django.utils.module_loading import import_string
+from django.utils.text import capfirst
+
+
+class SeleniumTestCaseBase(type(LiveServerTestCase)):
+    # List of browsers to dynamically create test classes for.
+    browsers = []
+    # A selenium hub URL to test against.
+    selenium_hub = None
+    # The external host Selenium Hub can reach.
+    external_host = None
+    # Sentinel value to differentiate browser-specific instances.
+    browser = None
+    # Run browsers in headless mode.
+    headless = False
+
+    def __new__(cls, name, bases, attrs):
+        """
+        Dynamically create new classes and add them to the test module when
+        multiple browsers specs are provided (e.g. --selenium=firefox,chrome).
+        """
+        test_class = super().__new__(cls, name, bases, attrs)
+        # If the test class is either browser-specific or a test base, return it.
+        if test_class.browser or not any(
+            name.startswith("test") and callable(value) for name, value in attrs.items()
+        ):
+            return test_class
+        elif test_class.browsers:
+            # Reuse the created test class to make it browser-specific.
+            # We can't rename it to include the browser name or create a
+            # subclass like we do with the remaining browsers as it would
+            # either duplicate tests or prevent pickling of its instances.
+            first_browser = test_class.browsers[0]
+            test_class.browser = first_browser
+            # Listen on an external interface if using a selenium hub.
+            host = test_class.host if not test_class.selenium_hub else "0.0.0.0"
+            test_class.host = host
+            test_class.external_host = cls.external_host
+            # Create subclasses for each of the remaining browsers and expose
+            # them through the test's module namespace.
+            module = sys.modules[test_class.__module__]
+            for browser in test_class.browsers[1:]:
+                browser_test_class = cls.__new__(
+                    cls,
+                    "%s%s" % (capfirst(browser), name),
+                    (test_class,),
+                    {
+                        "browser": browser,
+                        "host": host,
+                        "external_host": cls.external_host,
+                        "__module__": test_class.__module__,
+                    },
+                )
+                setattr(module, browser_test_class.__name__, browser_test_class)
+            return test_class
+        # If no browsers were specified, skip this class (it'll still be discovered).
+        return unittest.skip("No browsers specified.")(test_class)
+
+    @classmethod
+    def import_webdriver(cls, browser):
+        return import_string("selenium.webdriver.%s.webdriver.WebDriver" % browser)
+
+    @classmethod
+    def import_options(cls, browser):
+        return import_string("selenium.webdriver.%s.options.Options" % browser)
+
+    @classmethod
+    def get_capability(cls, browser):
+        from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
+
+        return getattr(DesiredCapabilities, browser.upper())
+
+    def create_options(self):
+        options = self.import_options(self.browser)()
+        if self.headless:
+            match self.browser:
+                case "chrome" | "edge":
+                    options.add_argument("--headless=new")
+                case "firefox":
+                    options.add_argument("-headless")
+        return options
+
+    def create_webdriver(self):
+        options = self.create_options()
+        if self.selenium_hub:
+            from selenium import webdriver
+
+            for key, value in self.get_capability(self.browser).items():
+                options.set_capability(key, value)
+
+            return webdriver.Remote(command_executor=self.selenium_hub, options=options)
+        return self.import_webdriver(self.browser)(options=options)
+
+
+class ChangeWindowSize:
+    def __init__(self, width, height, selenium):
+        self.selenium = selenium
+        self.new_size = (width, height)
+
+    def __enter__(self):
+        self.old_size = self.selenium.get_window_size()
+        self.selenium.set_window_size(*self.new_size)
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.selenium.set_window_size(self.old_size["width"], self.old_size["height"])
+
+
+@tag("selenium")
+class SeleniumTestCase(LiveServerTestCase, metaclass=SeleniumTestCaseBase):
+    implicit_wait = 10
+    external_host = None
+    screenshots = False
+
+    @classmethod
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        if not cls.screenshots:
+            return
+
+        for name, func in list(cls.__dict__.items()):
+            if not hasattr(func, "_screenshot_cases"):
+                continue
+            # Remove the main test.
+            delattr(cls, name)
+            # Add separate tests for each screenshot type.
+            for screenshot_case in getattr(func, "_screenshot_cases"):
+
+                @wraps(func)
+                def test(self, *args, _func=func, _case=screenshot_case, **kwargs):
+                    with getattr(self, _case)():
+                        return _func(self, *args, **kwargs)
+
+                test.__name__ = f"{name}_{screenshot_case}"
+                test.__qualname__ = f"{test.__qualname__}_{screenshot_case}"
+                test._screenshot_name = name
+                test._screenshot_case = screenshot_case
+                setattr(cls, test.__name__, test)
+
+    @classproperty
+    def live_server_url(cls):
+        return "http://%s:%s" % (cls.external_host or cls.host, cls.server_thread.port)
+
+    @classproperty
+    def allowed_host(cls):
+        return cls.external_host or cls.host
+
+    @classmethod
+    def setUpClass(cls):
+        cls.selenium = cls.create_webdriver()
+        cls.selenium.implicitly_wait(cls.implicit_wait)
+        super().setUpClass()
+        cls.addClassCleanup(cls._quit_selenium)
+
+    @contextmanager
+    def desktop_size(self):
+        with ChangeWindowSize(1280, 720, self.selenium):
+            yield
+
+    @contextmanager
+    def small_screen_size(self):
+        with ChangeWindowSize(1024, 768, self.selenium):
+            yield
+
+    @contextmanager
+    def mobile_size(self):
+        with ChangeWindowSize(360, 800, self.selenium):
+            yield
+
+    @contextmanager
+    def rtl(self):
+        with self.desktop_size():
+            with override_settings(LANGUAGE_CODE=settings.LANGUAGES_BIDI[-1]):
+                yield
+
+    @contextmanager
+    def dark(self):
+        # Navigate to a page before executing a script.
+        self.selenium.get(self.live_server_url)
+        self.selenium.execute_script("localStorage.setItem('theme', 'dark');")
+        with self.desktop_size():
+            try:
+                yield
+            finally:
+                self.selenium.execute_script("localStorage.removeItem('theme');")
+
+    def set_emulated_media(self, *, media=None, features=None):
+        if self.browser not in {"chrome", "edge"}:
+            self.skipTest(
+                "Emulation.setEmulatedMedia is only supported on Chromium and "
+                "Chrome-based browsers. See https://chromedevtools.github.io/devtools-"
+                "protocol/1-3/Emulation/#method-setEmulatedMedia for more details."
+            )
+        params = {}
+        if media is not None:
+            params["media"] = media
+        if features is not None:
+            params["features"] = features
+
+        # Not using .execute_cdp_cmd() as it isn't supported by the remote web driver
+        # when using --selenium-hub.
+        self.selenium.execute(
+            driver_command="executeCdpCommand",
+            params={"cmd": "Emulation.setEmulatedMedia", "params": params},
+        )
+
+    @contextmanager
+    def high_contrast(self):
+        self.set_emulated_media(features=[{"name": "forced-colors", "value": "active"}])
+        with self.desktop_size():
+            try:
+                yield
+            finally:
+                self.set_emulated_media(
+                    features=[{"name": "forced-colors", "value": "none"}]
+                )
+
+    def take_screenshot(self, name):
+        if not self.screenshots:
+            return
+        test = getattr(self, self._testMethodName)
+        filename = f"{test._screenshot_name}--{name}--{test._screenshot_case}.png"
+        path = Path.cwd() / "screenshots" / filename
+        path.parent.mkdir(exist_ok=True, parents=True)
+        self.selenium.save_screenshot(path)
+
+    @classmethod
+    def _quit_selenium(cls):
+        # quit() the WebDriver before attempting to terminate and join the
+        # single-threaded LiveServerThread to avoid a dead lock if the browser
+        # kept a connection alive.
+        if hasattr(cls, "selenium"):
+            cls.selenium.quit()
+
+    @contextmanager
+    def disable_implicit_wait(self):
+        """Disable the default implicit wait."""
+        self.selenium.implicitly_wait(0)
+        try:
+            yield
+        finally:
+            self.selenium.implicitly_wait(self.implicit_wait)
+
+
+def screenshot_cases(method_names):
+    if isinstance(method_names, str):
+        method_names = method_names.split(",")
+
+    def wrapper(func):
+        func._screenshot_cases = method_names
+        setattr(func, "tags", {"screenshot"}.union(getattr(func, "tags", set())))
+        return func
+
+    return wrapper

.venv/lib/python3.12/site-packages/django/test/signals.py

@@ -0,0 +1,253 @@
+import os
+import time
+import warnings
+
+from asgiref.local import Local
+
+from django.apps import apps
+from django.core.exceptions import ImproperlyConfigured
+from django.core.signals import setting_changed
+from django.db import connections, router
+from django.db.utils import ConnectionRouter
+from django.dispatch import Signal, receiver
+from django.utils import timezone
+from django.utils.formats import FORMAT_SETTINGS, reset_format_cache
+from django.utils.functional import empty
+
+template_rendered = Signal()
+
+# Most setting_changed receivers are supposed to be added below,
+# except for cases where the receiver is related to a contrib app.
+
+# Settings that may not work well when using 'override_settings' (#19031)
+COMPLEX_OVERRIDE_SETTINGS = {"DATABASES"}
+
+
+@receiver(setting_changed)
+def clear_cache_handlers(*, setting, **kwargs):
+    if setting == "CACHES":
+        from django.core.cache import caches, close_caches
+
+        close_caches()
+        caches._settings = caches.settings = caches.configure_settings(None)
+        caches._connections = Local()
+
+
+@receiver(setting_changed)
+def update_installed_apps(*, setting, **kwargs):
+    if setting == "INSTALLED_APPS":
+        # Rebuild any AppDirectoriesFinder instance.
+        from django.contrib.staticfiles.finders import get_finder
+
+        get_finder.cache_clear()
+        # Rebuild management commands cache
+        from django.core.management import get_commands
+
+        get_commands.cache_clear()
+        # Rebuild get_app_template_dirs cache.
+        from django.template.utils import get_app_template_dirs
+
+        get_app_template_dirs.cache_clear()
+        # Rebuild translations cache.
+        from django.utils.translation import trans_real
+
+        trans_real._translations = {}
+
+
+@receiver(setting_changed)
+def update_connections_time_zone(*, setting, **kwargs):
+    if setting == "TIME_ZONE":
+        # Reset process time zone
+        if hasattr(time, "tzset"):
+            if kwargs["value"]:
+                os.environ["TZ"] = kwargs["value"]
+            else:
+                os.environ.pop("TZ", None)
+            time.tzset()
+
+        # Reset local time zone cache
+        timezone.get_default_timezone.cache_clear()
+
+    # Reset the database connections' time zone
+    if setting in {"TIME_ZONE", "USE_TZ"}:
+        for conn in connections.all(initialized_only=True):
+            try:
+                del conn.timezone
+            except AttributeError:
+                pass
+            try:
+                del conn.timezone_name
+            except AttributeError:
+                pass
+            conn.ensure_timezone()
+
+
+@receiver(setting_changed)
+def clear_routers_cache(*, setting, **kwargs):
+    if setting == "DATABASE_ROUTERS":
+        router.routers = ConnectionRouter().routers
+
+
+@receiver(setting_changed)
+def reset_template_engines(*, setting, **kwargs):
+    if setting in {
+        "TEMPLATES",
+        "DEBUG",
+        "INSTALLED_APPS",
+    }:
+        from django.template import engines
+
+        try:
+            del engines.templates
+        except AttributeError:
+            pass
+        engines._templates = None
+        engines._engines = {}
+        from django.template.engine import Engine
+
+        Engine.get_default.cache_clear()
+        from django.forms.renderers import get_default_renderer
+
+        get_default_renderer.cache_clear()
+
+
+@receiver(setting_changed)
+def storages_changed(*, setting, **kwargs):
+    from django.contrib.staticfiles.storage import staticfiles_storage
+    from django.core.files.storage import default_storage, storages
+
+    if setting in (
+        "STORAGES",
+        "STATIC_ROOT",
+        "STATIC_URL",
+    ):
+        try:
+            del storages.backends
+        except AttributeError:
+            pass
+        storages._backends = None
+        storages._storages = {}
+
+        default_storage._wrapped = empty
+        staticfiles_storage._wrapped = empty
+
+
+@receiver(setting_changed)
+def clear_serializers_cache(*, setting, **kwargs):
+    if setting == "SERIALIZATION_MODULES":
+        from django.core import serializers
+
+        serializers._serializers = {}
+
+
+@receiver(setting_changed)
+def language_changed(*, setting, **kwargs):
+    if setting in {"LANGUAGES", "LANGUAGE_CODE", "LOCALE_PATHS"}:
+        from django.utils.translation import trans_real
+
+        trans_real._default = None
+        trans_real._active = Local()
+    if setting in {"LANGUAGES", "LOCALE_PATHS"}:
+        from django.utils.translation import trans_real
+
+        trans_real._translations = {}
+        trans_real.check_for_language.cache_clear()
+
+
+@receiver(setting_changed)
+def localize_settings_changed(*, setting, **kwargs):
+    if setting in FORMAT_SETTINGS or setting == "USE_THOUSAND_SEPARATOR":
+        reset_format_cache()
+
+
+@receiver(setting_changed)
+def complex_setting_changed(*, enter, setting, **kwargs):
+    if enter and setting in COMPLEX_OVERRIDE_SETTINGS:
+        # Considering the current implementation of the signals framework,
+        # this stacklevel shows the line containing the override_settings call.
+        warnings.warn(
+            f"Overriding setting {setting} can lead to unexpected behavior.",
+            stacklevel=5,
+        )
+
+
+@receiver(setting_changed)
+def root_urlconf_changed(*, setting, **kwargs):
+    if setting == "ROOT_URLCONF":
+        from django.urls import clear_url_caches, set_urlconf
+
+        clear_url_caches()
+        set_urlconf(None)
+
+
+@receiver(setting_changed)
+def static_storage_changed(*, setting, **kwargs):
+    if setting in {
+        "STATIC_ROOT",
+        "STATIC_URL",
+    }:
+        from django.contrib.staticfiles.storage import staticfiles_storage
+
+        staticfiles_storage._wrapped = empty
+
+
+@receiver(setting_changed)
+def static_finders_changed(*, setting, **kwargs):
+    if setting in {
+        "STATICFILES_DIRS",
+        "STATIC_ROOT",
+    }:
+        from django.contrib.staticfiles.finders import get_finder
+
+        get_finder.cache_clear()
+
+
+@receiver(setting_changed)
+def form_renderer_changed(*, setting, **kwargs):
+    if setting == "FORM_RENDERER":
+        from django.forms.renderers import get_default_renderer
+
+        get_default_renderer.cache_clear()
+
+
+@receiver(setting_changed)
+def auth_password_validators_changed(*, setting, **kwargs):
+    if setting == "AUTH_PASSWORD_VALIDATORS":
+        from django.contrib.auth.password_validation import (
+            get_default_password_validators,
+        )
+
+        get_default_password_validators.cache_clear()
+
+
+@receiver(setting_changed)
+def user_model_swapped(*, setting, **kwargs):
+    if setting == "AUTH_USER_MODEL":
+        apps.clear_cache()
+        try:
+            from django.contrib.auth import get_user_model
+
+            UserModel = get_user_model()
+        except ImproperlyConfigured:
+            # Some tests set an invalid AUTH_USER_MODEL.
+            pass
+        else:
+            from django.contrib.auth import backends
+
+            backends.UserModel = UserModel
+
+            from django.contrib.auth import forms
+
+            forms.UserModel = UserModel
+
+            from django.contrib.auth.handlers import modwsgi
+
+            modwsgi.UserModel = UserModel
+
+            from django.contrib.auth.management.commands import changepassword
+
+            changepassword.UserModel = UserModel
+
+            from django.contrib.auth import views
+
+            views.UserModel = UserModel