before send to remote

env/lib/python3.8/site-packages/django/__init__.py

@@ -0,0 +1,24 @@
+from django.utils.version import get_version
+
+VERSION = (4, 1, 0, "final", 0)
+
+__version__ = get_version(VERSION)
+
+
+def setup(set_prefix=True):
+    """
+    Configure the settings (this happens as a side effect of accessing the
+    first setting), configure logging and populate the app registry.
+    Set the thread-local urlresolvers script prefix if `set_prefix` is True.
+    """
+    from django.apps import apps
+    from django.conf import settings
+    from django.urls import set_script_prefix
+    from django.utils.log import configure_logging
+
+    configure_logging(settings.LOGGING_CONFIG, settings.LOGGING)
+    if set_prefix:
+        set_script_prefix(
+            "/" if settings.FORCE_SCRIPT_NAME is None else settings.FORCE_SCRIPT_NAME
+        )
+    apps.populate(settings.INSTALLED_APPS)

env/lib/python3.8/site-packages/django/__main__.py

@@ -0,0 +1,9 @@
+"""
+Invokes django-admin when the django module is run as a script.
+
+Example: python -m django check
+"""
+from django.core import management
+
+if __name__ == "__main__":
+    management.execute_from_command_line()

env/lib/python3.8/site-packages/django/apps/__init__.py

@@ -0,0 +1,4 @@
+from .config import AppConfig
+from .registry import apps
+
+__all__ = ["AppConfig", "apps"]

env/lib/python3.8/site-packages/django/apps/config.py

@@ -0,0 +1,274 @@
+import inspect
+import os
+from importlib import import_module
+
+from django.core.exceptions import ImproperlyConfigured
+from django.utils.functional import cached_property
+from django.utils.module_loading import import_string, module_has_submodule
+
+APPS_MODULE_NAME = "apps"
+MODELS_MODULE_NAME = "models"
+
+
+class AppConfig:
+    """Class representing a Django application and its configuration."""
+
+    def __init__(self, app_name, app_module):
+        # Full Python path to the application e.g. 'django.contrib.admin'.
+        self.name = app_name
+
+        # Root module for the application e.g. <module 'django.contrib.admin'
+        # from 'django/contrib/admin/__init__.py'>.
+        self.module = app_module
+
+        # Reference to the Apps registry that holds this AppConfig. Set by the
+        # registry when it registers the AppConfig instance.
+        self.apps = None
+
+        # The following attributes could be defined at the class level in a
+        # subclass, hence the test-and-set pattern.
+
+        # Last component of the Python path to the application e.g. 'admin'.
+        # This value must be unique across a Django project.
+        if not hasattr(self, "label"):
+            self.label = app_name.rpartition(".")[2]
+        if not self.label.isidentifier():
+            raise ImproperlyConfigured(
+                "The app label '%s' is not a valid Python identifier." % self.label
+            )
+
+        # Human-readable name for the application e.g. "Admin".
+        if not hasattr(self, "verbose_name"):
+            self.verbose_name = self.label.title()
+
+        # Filesystem path to the application directory e.g.
+        # '/path/to/django/contrib/admin'.
+        if not hasattr(self, "path"):
+            self.path = self._path_from_module(app_module)
+
+        # Module containing models e.g. <module 'django.contrib.admin.models'
+        # from 'django/contrib/admin/models.py'>. Set by import_models().
+        # None if the application doesn't have a models module.
+        self.models_module = None
+
+        # Mapping of lowercase model names to model classes. Initially set to
+        # None to prevent accidental access before import_models() runs.
+        self.models = None
+
+    def __repr__(self):
+        return "<%s: %s>" % (self.__class__.__name__, self.label)
+
+    @cached_property
+    def default_auto_field(self):
+        from django.conf import settings
+
+        return settings.DEFAULT_AUTO_FIELD
+
+    @property
+    def _is_default_auto_field_overridden(self):
+        return self.__class__.default_auto_field is not AppConfig.default_auto_field
+
+    def _path_from_module(self, module):
+        """Attempt to determine app's filesystem path from its module."""
+        # See #21874 for extended discussion of the behavior of this method in
+        # various cases.
+        # Convert to list because __path__ may not support indexing.
+        paths = list(getattr(module, "__path__", []))
+        if len(paths) != 1:
+            filename = getattr(module, "__file__", None)
+            if filename is not None:
+                paths = [os.path.dirname(filename)]
+            else:
+                # For unknown reasons, sometimes the list returned by __path__
+                # contains duplicates that must be removed (#25246).
+                paths = list(set(paths))
+        if len(paths) > 1:
+            raise ImproperlyConfigured(
+                "The app module %r has multiple filesystem locations (%r); "
+                "you must configure this app with an AppConfig subclass "
+                "with a 'path' class attribute." % (module, paths)
+            )
+        elif not paths:
+            raise ImproperlyConfigured(
+                "The app module %r has no filesystem location, "
+                "you must configure this app with an AppConfig subclass "
+                "with a 'path' class attribute." % module
+            )
+        return paths[0]
+
+    @classmethod
+    def create(cls, entry):
+        """
+        Factory that creates an app config from an entry in INSTALLED_APPS.
+        """
+        # create() eventually returns app_config_class(app_name, app_module).
+        app_config_class = None
+        app_name = None
+        app_module = None
+
+        # If import_module succeeds, entry points to the app module.
+        try:
+            app_module = import_module(entry)
+        except Exception:
+            pass
+        else:
+            # If app_module has an apps submodule that defines a single
+            # AppConfig subclass, use it automatically.
+            # To prevent this, an AppConfig subclass can declare a class
+            # variable default = False.
+            # If the apps module defines more than one AppConfig subclass,
+            # the default one can declare default = True.
+            if module_has_submodule(app_module, APPS_MODULE_NAME):
+                mod_path = "%s.%s" % (entry, APPS_MODULE_NAME)
+                mod = import_module(mod_path)
+                # Check if there's exactly one AppConfig candidate,
+                # excluding those that explicitly define default = False.
+                app_configs = [
+                    (name, candidate)
+                    for name, candidate in inspect.getmembers(mod, inspect.isclass)
+                    if (
+                        issubclass(candidate, cls)
+                        and candidate is not cls
+                        and getattr(candidate, "default", True)
+                    )
+                ]
+                if len(app_configs) == 1:
+                    app_config_class = app_configs[0][1]
+                else:
+                    # Check if there's exactly one AppConfig subclass,
+                    # among those that explicitly define default = True.
+                    app_configs = [
+                        (name, candidate)
+                        for name, candidate in app_configs
+                        if getattr(candidate, "default", False)
+                    ]
+                    if len(app_configs) > 1:
+                        candidates = [repr(name) for name, _ in app_configs]
+                        raise RuntimeError(
+                            "%r declares more than one default AppConfig: "
+                            "%s." % (mod_path, ", ".join(candidates))
+                        )
+                    elif len(app_configs) == 1:
+                        app_config_class = app_configs[0][1]
+
+            # Use the default app config class if we didn't find anything.
+            if app_config_class is None:
+                app_config_class = cls
+                app_name = entry
+
+        # If import_string succeeds, entry is an app config class.
+        if app_config_class is None:
+            try:
+                app_config_class = import_string(entry)
+            except Exception:
+                pass
+        # If both import_module and import_string failed, it means that entry
+        # doesn't have a valid value.
+        if app_module is None and app_config_class is None:
+            # If the last component of entry starts with an uppercase letter,
+            # then it was likely intended to be an app config class; if not,
+            # an app module. Provide a nice error message in both cases.
+            mod_path, _, cls_name = entry.rpartition(".")
+            if mod_path and cls_name[0].isupper():
+                # We could simply re-trigger the string import exception, but
+                # we're going the extra mile and providing a better error
+                # message for typos in INSTALLED_APPS.
+                # This may raise ImportError, which is the best exception
+                # possible if the module at mod_path cannot be imported.
+                mod = import_module(mod_path)
+                candidates = [
+                    repr(name)
+                    for name, candidate in inspect.getmembers(mod, inspect.isclass)
+                    if issubclass(candidate, cls) and candidate is not cls
+                ]
+                msg = "Module '%s' does not contain a '%s' class." % (
+                    mod_path,
+                    cls_name,
+                )
+                if candidates:
+                    msg += " Choices are: %s." % ", ".join(candidates)
+                raise ImportError(msg)
+            else:
+                # Re-trigger the module import exception.
+                import_module(entry)
+
+        # Check for obvious errors. (This check prevents duck typing, but
+        # it could be removed if it became a problem in practice.)
+        if not issubclass(app_config_class, AppConfig):
+            raise ImproperlyConfigured("'%s' isn't a subclass of AppConfig." % entry)
+
+        # Obtain app name here rather than in AppClass.__init__ to keep
+        # all error checking for entries in INSTALLED_APPS in one place.
+        if app_name is None:
+            try:
+                app_name = app_config_class.name
+            except AttributeError:
+                raise ImproperlyConfigured("'%s' must supply a name attribute." % entry)
+
+        # Ensure app_name points to a valid module.
+        try:
+            app_module = import_module(app_name)
+        except ImportError:
+            raise ImproperlyConfigured(
+                "Cannot import '%s'. Check that '%s.%s.name' is correct."
+                % (
+                    app_name,
+                    app_config_class.__module__,
+                    app_config_class.__qualname__,
+                )
+            )
+
+        # Entry is a path to an app config class.
+        return app_config_class(app_name, app_module)
+
+    def get_model(self, model_name, require_ready=True):
+        """
+        Return the model with the given case-insensitive model_name.
+
+        Raise LookupError if no model exists with this name.
+        """
+        if require_ready:
+            self.apps.check_models_ready()
+        else:
+            self.apps.check_apps_ready()
+        try:
+            return self.models[model_name.lower()]
+        except KeyError:
+            raise LookupError(
+                "App '%s' doesn't have a '%s' model." % (self.label, model_name)
+            )
+
+    def get_models(self, include_auto_created=False, include_swapped=False):
+        """
+        Return an iterable of models.
+
+        By default, the following models aren't included:
+
+        - auto-created models for many-to-many relations without
+          an explicit intermediate table,
+        - models that have been swapped out.
+
+        Set the corresponding keyword argument to True to include such models.
+        Keyword arguments aren't documented; they're a private API.
+        """
+        self.apps.check_models_ready()
+        for model in self.models.values():
+            if model._meta.auto_created and not include_auto_created:
+                continue
+            if model._meta.swapped and not include_swapped:
+                continue
+            yield model
+
+    def import_models(self):
+        # Dictionary of models for this app, primarily maintained in the
+        # 'all_models' attribute of the Apps this AppConfig is attached to.
+        self.models = self.apps.all_models[self.label]
+
+        if module_has_submodule(self.module, MODELS_MODULE_NAME):
+            models_module_name = "%s.%s" % (self.name, MODELS_MODULE_NAME)
+            self.models_module = import_module(models_module_name)
+
+    def ready(self):
+        """
+        Override this method in subclasses to run code when Django starts.
+        """

env/lib/python3.8/site-packages/django/apps/registry.py

@@ -0,0 +1,436 @@
+import functools
+import sys
+import threading
+import warnings
+from collections import Counter, defaultdict
+from functools import partial
+
+from django.core.exceptions import AppRegistryNotReady, ImproperlyConfigured
+
+from .config import AppConfig
+
+
+class Apps:
+    """
+    A registry that stores the configuration of installed applications.
+
+    It also keeps track of models, e.g. to provide reverse relations.
+    """
+
+    def __init__(self, installed_apps=()):
+        # installed_apps is set to None when creating the main registry
+        # because it cannot be populated at that point. Other registries must
+        # provide a list of installed apps and are populated immediately.
+        if installed_apps is None and hasattr(sys.modules[__name__], "apps"):
+            raise RuntimeError("You must supply an installed_apps argument.")
+
+        # Mapping of app labels => model names => model classes. Every time a
+        # model is imported, ModelBase.__new__ calls apps.register_model which
+        # creates an entry in all_models. All imported models are registered,
+        # regardless of whether they're defined in an installed application
+        # and whether the registry has been populated. Since it isn't possible
+        # to reimport a module safely (it could reexecute initialization code)
+        # all_models is never overridden or reset.
+        self.all_models = defaultdict(dict)
+
+        # Mapping of labels to AppConfig instances for installed apps.
+        self.app_configs = {}
+
+        # Stack of app_configs. Used to store the current state in
+        # set_available_apps and set_installed_apps.
+        self.stored_app_configs = []
+
+        # Whether the registry is populated.
+        self.apps_ready = self.models_ready = self.ready = False
+        # For the autoreloader.
+        self.ready_event = threading.Event()
+
+        # Lock for thread-safe population.
+        self._lock = threading.RLock()
+        self.loading = False
+
+        # Maps ("app_label", "modelname") tuples to lists of functions to be
+        # called when the corresponding model is ready. Used by this class's
+        # `lazy_model_operation()` and `do_pending_operations()` methods.
+        self._pending_operations = defaultdict(list)
+
+        # Populate apps and models, unless it's the main registry.
+        if installed_apps is not None:
+            self.populate(installed_apps)
+
+    def populate(self, installed_apps=None):
+        """
+        Load application configurations and models.
+
+        Import each application module and then each model module.
+
+        It is thread-safe and idempotent, but not reentrant.
+        """
+        if self.ready:
+            return
+
+        # populate() might be called by two threads in parallel on servers
+        # that create threads before initializing the WSGI callable.
+        with self._lock:
+            if self.ready:
+                return
+
+            # An RLock prevents other threads from entering this section. The
+            # compare and set operation below is atomic.
+            if self.loading:
+                # Prevent reentrant calls to avoid running AppConfig.ready()
+                # methods twice.
+                raise RuntimeError("populate() isn't reentrant")
+            self.loading = True
+
+            # Phase 1: initialize app configs and import app modules.
+            for entry in installed_apps:
+                if isinstance(entry, AppConfig):
+                    app_config = entry
+                else:
+                    app_config = AppConfig.create(entry)
+                if app_config.label in self.app_configs:
+                    raise ImproperlyConfigured(
+                        "Application labels aren't unique, "
+                        "duplicates: %s" % app_config.label
+                    )
+
+                self.app_configs[app_config.label] = app_config
+                app_config.apps = self
+
+            # Check for duplicate app names.
+            counts = Counter(
+                app_config.name for app_config in self.app_configs.values()
+            )
+            duplicates = [name for name, count in counts.most_common() if count > 1]
+            if duplicates:
+                raise ImproperlyConfigured(
+                    "Application names aren't unique, "
+                    "duplicates: %s" % ", ".join(duplicates)
+                )
+
+            self.apps_ready = True
+
+            # Phase 2: import models modules.
+            for app_config in self.app_configs.values():
+                app_config.import_models()
+
+            self.clear_cache()
+
+            self.models_ready = True
+
+            # Phase 3: run ready() methods of app configs.
+            for app_config in self.get_app_configs():
+                app_config.ready()
+
+            self.ready = True
+            self.ready_event.set()
+
+    def check_apps_ready(self):
+        """Raise an exception if all apps haven't been imported yet."""
+        if not self.apps_ready:
+            from django.conf import settings
+
+            # If "not ready" is due to unconfigured settings, accessing
+            # INSTALLED_APPS raises a more helpful ImproperlyConfigured
+            # exception.
+            settings.INSTALLED_APPS
+            raise AppRegistryNotReady("Apps aren't loaded yet.")
+
+    def check_models_ready(self):
+        """Raise an exception if all models haven't been imported yet."""
+        if not self.models_ready:
+            raise AppRegistryNotReady("Models aren't loaded yet.")
+
+    def get_app_configs(self):
+        """Import applications and return an iterable of app configs."""
+        self.check_apps_ready()
+        return self.app_configs.values()
+
+    def get_app_config(self, app_label):
+        """
+        Import applications and returns an app config for the given label.
+
+        Raise LookupError if no application exists with this label.
+        """
+        self.check_apps_ready()
+        try:
+            return self.app_configs[app_label]
+        except KeyError:
+            message = "No installed app with label '%s'." % app_label
+            for app_config in self.get_app_configs():
+                if app_config.name == app_label:
+                    message += " Did you mean '%s'?" % app_config.label
+                    break
+            raise LookupError(message)
+
+    # This method is performance-critical at least for Django's test suite.
+    @functools.lru_cache(maxsize=None)
+    def get_models(self, include_auto_created=False, include_swapped=False):
+        """
+        Return a list of all installed models.
+
+        By default, the following models aren't included:
+
+        - auto-created models for many-to-many relations without
+          an explicit intermediate table,
+        - models that have been swapped out.
+
+        Set the corresponding keyword argument to True to include such models.
+        """
+        self.check_models_ready()
+
+        result = []
+        for app_config in self.app_configs.values():
+            result.extend(app_config.get_models(include_auto_created, include_swapped))
+        return result
+
+    def get_model(self, app_label, model_name=None, require_ready=True):
+        """
+        Return the model matching the given app_label and model_name.
+
+        As a shortcut, app_label may be in the form <app_label>.<model_name>.
+
+        model_name is case-insensitive.
+
+        Raise LookupError if no application exists with this label, or no
+        model exists with this name in the application. Raise ValueError if
+        called with a single argument that doesn't contain exactly one dot.
+        """
+        if require_ready:
+            self.check_models_ready()
+        else:
+            self.check_apps_ready()
+
+        if model_name is None:
+            app_label, model_name = app_label.split(".")
+
+        app_config = self.get_app_config(app_label)
+
+        if not require_ready and app_config.models is None:
+            app_config.import_models()
+
+        return app_config.get_model(model_name, require_ready=require_ready)
+
+    def register_model(self, app_label, model):
+        # Since this method is called when models are imported, it cannot
+        # perform imports because of the risk of import loops. It mustn't
+        # call get_app_config().
+        model_name = model._meta.model_name
+        app_models = self.all_models[app_label]
+        if model_name in app_models:
+            if (
+                model.__name__ == app_models[model_name].__name__
+                and model.__module__ == app_models[model_name].__module__
+            ):
+                warnings.warn(
+                    "Model '%s.%s' was already registered. Reloading models is not "
+                    "advised as it can lead to inconsistencies, most notably with "
+                    "related models." % (app_label, model_name),
+                    RuntimeWarning,
+                    stacklevel=2,
+                )
+            else:
+                raise RuntimeError(
+                    "Conflicting '%s' models in application '%s': %s and %s."
+                    % (model_name, app_label, app_models[model_name], model)
+                )
+        app_models[model_name] = model
+        self.do_pending_operations(model)
+        self.clear_cache()
+
+    def is_installed(self, app_name):
+        """
+        Check whether an application with this name exists in the registry.
+
+        app_name is the full name of the app e.g. 'django.contrib.admin'.
+        """
+        self.check_apps_ready()
+        return any(ac.name == app_name for ac in self.app_configs.values())
+
+    def get_containing_app_config(self, object_name):
+        """
+        Look for an app config containing a given object.
+
+        object_name is the dotted Python path to the object.
+
+        Return the app config for the inner application in case of nesting.
+        Return None if the object isn't in any registered app config.
+        """
+        self.check_apps_ready()
+        candidates = []
+        for app_config in self.app_configs.values():
+            if object_name.startswith(app_config.name):
+                subpath = object_name[len(app_config.name) :]
+                if subpath == "" or subpath[0] == ".":
+                    candidates.append(app_config)
+        if candidates:
+            return sorted(candidates, key=lambda ac: -len(ac.name))[0]
+
+    def get_registered_model(self, app_label, model_name):
+        """
+        Similar to get_model(), but doesn't require that an app exists with
+        the given app_label.
+
+        It's safe to call this method at import time, even while the registry
+        is being populated.
+        """
+        model = self.all_models[app_label].get(model_name.lower())
+        if model is None:
+            raise LookupError("Model '%s.%s' not registered." % (app_label, model_name))
+        return model
+
+    @functools.lru_cache(maxsize=None)
+    def get_swappable_settings_name(self, to_string):
+        """
+        For a given model string (e.g. "auth.User"), return the name of the
+        corresponding settings name if it refers to a swappable model. If the
+        referred model is not swappable, return None.
+
+        This method is decorated with lru_cache because it's performance
+        critical when it comes to migrations. Since the swappable settings don't
+        change after Django has loaded the settings, there is no reason to get
+        the respective settings attribute over and over again.
+        """
+        to_string = to_string.lower()
+        for model in self.get_models(include_swapped=True):
+            swapped = model._meta.swapped
+            # Is this model swapped out for the model given by to_string?
+            if swapped and swapped.lower() == to_string:
+                return model._meta.swappable
+            # Is this model swappable and the one given by to_string?
+            if model._meta.swappable and model._meta.label_lower == to_string:
+                return model._meta.swappable
+        return None
+
+    def set_available_apps(self, available):
+        """
+        Restrict the set of installed apps used by get_app_config[s].
+
+        available must be an iterable of application names.
+
+        set_available_apps() must be balanced with unset_available_apps().
+
+        Primarily used for performance optimization in TransactionTestCase.
+
+        This method is safe in the sense that it doesn't trigger any imports.
+        """
+        available = set(available)
+        installed = {app_config.name for app_config in self.get_app_configs()}
+        if not available.issubset(installed):
+            raise ValueError(
+                "Available apps isn't a subset of installed apps, extra apps: %s"
+                % ", ".join(available - installed)
+            )
+
+        self.stored_app_configs.append(self.app_configs)
+        self.app_configs = {
+            label: app_config
+            for label, app_config in self.app_configs.items()
+            if app_config.name in available
+        }
+        self.clear_cache()
+
+    def unset_available_apps(self):
+        """Cancel a previous call to set_available_apps()."""
+        self.app_configs = self.stored_app_configs.pop()
+        self.clear_cache()
+
+    def set_installed_apps(self, installed):
+        """
+        Enable a different set of installed apps for get_app_config[s].
+
+        installed must be an iterable in the same format as INSTALLED_APPS.
+
+        set_installed_apps() must be balanced with unset_installed_apps(),
+        even if it exits with an exception.
+
+        Primarily used as a receiver of the setting_changed signal in tests.
+
+        This method may trigger new imports, which may add new models to the
+        registry of all imported models. They will stay in the registry even
+        after unset_installed_apps(). Since it isn't possible to replay
+        imports safely (e.g. that could lead to registering listeners twice),
+        models are registered when they're imported and never removed.
+        """
+        if not self.ready:
+            raise AppRegistryNotReady("App registry isn't ready yet.")
+        self.stored_app_configs.append(self.app_configs)
+        self.app_configs = {}
+        self.apps_ready = self.models_ready = self.loading = self.ready = False
+        self.clear_cache()
+        self.populate(installed)
+
+    def unset_installed_apps(self):
+        """Cancel a previous call to set_installed_apps()."""
+        self.app_configs = self.stored_app_configs.pop()
+        self.apps_ready = self.models_ready = self.ready = True
+        self.clear_cache()
+
+    def clear_cache(self):
+        """
+        Clear all internal caches, for methods that alter the app registry.
+
+        This is mostly used in tests.
+        """
+        # Call expire cache on each model. This will purge
+        # the relation tree and the fields cache.
+        self.get_models.cache_clear()
+        if self.ready:
+            # Circumvent self.get_models() to prevent that the cache is refilled.
+            # This particularly prevents that an empty value is cached while cloning.
+            for app_config in self.app_configs.values():
+                for model in app_config.get_models(include_auto_created=True):
+                    model._meta._expire_cache()
+
+    def lazy_model_operation(self, function, *model_keys):
+        """
+        Take a function and a number of ("app_label", "modelname") tuples, and
+        when all the corresponding models have been imported and registered,
+        call the function with the model classes as its arguments.
+
+        The function passed to this method must accept exactly n models as
+        arguments, where n=len(model_keys).
+        """
+        # Base case: no arguments, just execute the function.
+        if not model_keys:
+            function()
+        # Recursive case: take the head of model_keys, wait for the
+        # corresponding model class to be imported and registered, then apply
+        # that argument to the supplied function. Pass the resulting partial
+        # to lazy_model_operation() along with the remaining model args and
+        # repeat until all models are loaded and all arguments are applied.
+        else:
+            next_model, *more_models = model_keys
+
+            # This will be executed after the class corresponding to next_model
+            # has been imported and registered. The `func` attribute provides
+            # duck-type compatibility with partials.
+            def apply_next_model(model):
+                next_function = partial(apply_next_model.func, model)
+                self.lazy_model_operation(next_function, *more_models)
+
+            apply_next_model.func = function
+
+            # If the model has already been imported and registered, partially
+            # apply it to the function now. If not, add it to the list of
+            # pending operations for the model, where it will be executed with
+            # the model class as its sole argument once the model is ready.
+            try:
+                model_class = self.get_registered_model(*next_model)
+            except LookupError:
+                self._pending_operations[next_model].append(apply_next_model)
+            else:
+                apply_next_model(model_class)
+
+    def do_pending_operations(self, model):
+        """
+        Take a newly-prepared model and pass it to each function waiting for
+        it. This is called at the very end of Apps.register_model().
+        """
+        key = model._meta.app_label, model._meta.model_name
+        for function in self._pending_operations.pop(key, []):
+            function(model)
+
+
+apps = Apps(installed_apps=None)

env/lib/python3.8/site-packages/django/conf/__init__.py

@@ -0,0 +1,308 @@
+"""
+Settings and configuration for Django.
+
+Read values from the module specified by the DJANGO_SETTINGS_MODULE environment
+variable, and then from django.conf.global_settings; see the global_settings.py
+for a list of all possible variables.
+"""
+
+import importlib
+import os
+import time
+import traceback
+import warnings
+from pathlib import Path
+
+import django
+from django.conf import global_settings
+from django.core.exceptions import ImproperlyConfigured
+from django.utils.deprecation import RemovedInDjango50Warning
+from django.utils.functional import LazyObject, empty
+
+ENVIRONMENT_VARIABLE = "DJANGO_SETTINGS_MODULE"
+
+# RemovedInDjango50Warning
+USE_DEPRECATED_PYTZ_DEPRECATED_MSG = (
+    "The USE_DEPRECATED_PYTZ setting, and support for pytz timezones is "
+    "deprecated in favor of the stdlib zoneinfo module. Please update your "
+    "code to use zoneinfo and remove the USE_DEPRECATED_PYTZ setting."
+)
+
+USE_L10N_DEPRECATED_MSG = (
+    "The USE_L10N setting is deprecated. Starting with Django 5.0, localized "
+    "formatting of data will always be enabled. For example Django will "
+    "display numbers and dates using the format of the current locale."
+)
+
+CSRF_COOKIE_MASKED_DEPRECATED_MSG = (
+    "The CSRF_COOKIE_MASKED transitional setting is deprecated. Support for "
+    "it will be removed in Django 5.0."
+)
+
+
+class SettingsReference(str):
+    """
+    String subclass which references a current settings value. It's treated as
+    the value in memory but serializes to a settings.NAME attribute reference.
+    """
+
+    def __new__(self, value, setting_name):
+        return str.__new__(self, value)
+
+    def __init__(self, value, setting_name):
+        self.setting_name = setting_name
+
+
+class LazySettings(LazyObject):
+    """
+    A lazy proxy for either global Django settings or a custom settings object.
+    The user can manually configure settings prior to using them. Otherwise,
+    Django uses the settings module pointed to by DJANGO_SETTINGS_MODULE.
+    """
+
+    def _setup(self, name=None):
+        """
+        Load the settings module pointed to by the environment variable. This
+        is used the first time settings are needed, if the user hasn't
+        configured settings manually.
+        """
+        settings_module = os.environ.get(ENVIRONMENT_VARIABLE)
+        if not settings_module:
+            desc = ("setting %s" % name) if name else "settings"
+            raise ImproperlyConfigured(
+                "Requested %s, but settings are not configured. "
+                "You must either define the environment variable %s "
+                "or call settings.configure() before accessing settings."
+                % (desc, ENVIRONMENT_VARIABLE)
+            )
+
+        self._wrapped = Settings(settings_module)
+
+    def __repr__(self):
+        # Hardcode the class name as otherwise it yields 'Settings'.
+        if self._wrapped is empty:
+            return "<LazySettings [Unevaluated]>"
+        return '<LazySettings "%(settings_module)s">' % {
+            "settings_module": self._wrapped.SETTINGS_MODULE,
+        }
+
+    def __getattr__(self, name):
+        """Return the value of a setting and cache it in self.__dict__."""
+        if (_wrapped := self._wrapped) is empty:
+            self._setup(name)
+            _wrapped = self._wrapped
+        val = getattr(_wrapped, name)
+
+        # Special case some settings which require further modification.
+        # This is done here for performance reasons so the modified value is cached.
+        if name in {"MEDIA_URL", "STATIC_URL"} and val is not None:
+            val = self._add_script_prefix(val)
+        elif name == "SECRET_KEY" and not val:
+            raise ImproperlyConfigured("The SECRET_KEY setting must not be empty.")
+
+        self.__dict__[name] = val
+        return val
+
+    def __setattr__(self, name, value):
+        """
+        Set the value of setting. Clear all cached values if _wrapped changes
+        (@override_settings does this) or clear single values when set.
+        """
+        if name == "_wrapped":
+            self.__dict__.clear()
+        else:
+            self.__dict__.pop(name, None)
+        super().__setattr__(name, value)
+
+    def __delattr__(self, name):
+        """Delete a setting and clear it from cache if needed."""
+        super().__delattr__(name)
+        self.__dict__.pop(name, None)
+
+    def configure(self, default_settings=global_settings, **options):
+        """
+        Called to manually configure the settings. The 'default_settings'
+        parameter sets where to retrieve any unspecified values from (its
+        argument must support attribute access (__getattr__)).
+        """
+        if self._wrapped is not empty:
+            raise RuntimeError("Settings already configured.")
+        holder = UserSettingsHolder(default_settings)
+        for name, value in options.items():
+            if not name.isupper():
+                raise TypeError("Setting %r must be uppercase." % name)
+            setattr(holder, name, value)
+        self._wrapped = holder
+
+    @staticmethod
+    def _add_script_prefix(value):
+        """
+        Add SCRIPT_NAME prefix to relative paths.
+
+        Useful when the app is being served at a subpath and manually prefixing
+        subpath to STATIC_URL and MEDIA_URL in settings is inconvenient.
+        """
+        # Don't apply prefix to absolute paths and URLs.
+        if value.startswith(("http://", "https://", "/")):
+            return value
+        from django.urls import get_script_prefix
+
+        return "%s%s" % (get_script_prefix(), value)
+
+    @property
+    def configured(self):
+        """Return True if the settings have already been configured."""
+        return self._wrapped is not empty
+
+    @property
+    def USE_L10N(self):
+        stack = traceback.extract_stack()
+        # Show a warning if the setting is used outside of Django.
+        # Stack index: -1 this line, -2 the LazyObject __getattribute__(),
+        # -3 the caller.
+        filename, _, _, _ = stack[-3]
+        if not filename.startswith(os.path.dirname(django.__file__)):
+            warnings.warn(
+                USE_L10N_DEPRECATED_MSG,
+                RemovedInDjango50Warning,
+                stacklevel=2,
+            )
+        return self.__getattr__("USE_L10N")
+
+    # RemovedInDjango50Warning.
+    @property
+    def _USE_L10N_INTERNAL(self):
+        # Special hook to avoid checking a traceback in internal use on hot
+        # paths.
+        return self.__getattr__("USE_L10N")
+
+
+class Settings:
+    def __init__(self, settings_module):
+        # update this dict from global settings (but only for ALL_CAPS settings)
+        for setting in dir(global_settings):
+            if setting.isupper():
+                setattr(self, setting, getattr(global_settings, setting))
+
+        # store the settings module in case someone later cares
+        self.SETTINGS_MODULE = settings_module
+
+        mod = importlib.import_module(self.SETTINGS_MODULE)
+
+        tuple_settings = (
+            "ALLOWED_HOSTS",
+            "INSTALLED_APPS",
+            "TEMPLATE_DIRS",
+            "LOCALE_PATHS",
+            "SECRET_KEY_FALLBACKS",
+        )
+        self._explicit_settings = set()
+        for setting in dir(mod):
+            if setting.isupper():
+                setting_value = getattr(mod, setting)
+
+                if setting in tuple_settings and not isinstance(
+                    setting_value, (list, tuple)
+                ):
+                    raise ImproperlyConfigured(
+                        "The %s setting must be a list or a tuple." % setting
+                    )
+                setattr(self, setting, setting_value)
+                self._explicit_settings.add(setting)
+
+        if self.USE_TZ is False and not self.is_overridden("USE_TZ"):
+            warnings.warn(
+                "The default value of USE_TZ will change from False to True "
+                "in Django 5.0. Set USE_TZ to False in your project settings "
+                "if you want to keep the current default behavior.",
+                category=RemovedInDjango50Warning,
+            )
+
+        if self.is_overridden("USE_DEPRECATED_PYTZ"):
+            warnings.warn(USE_DEPRECATED_PYTZ_DEPRECATED_MSG, RemovedInDjango50Warning)
+
+        if self.is_overridden("CSRF_COOKIE_MASKED"):
+            warnings.warn(CSRF_COOKIE_MASKED_DEPRECATED_MSG, RemovedInDjango50Warning)
+
+        if hasattr(time, "tzset") and self.TIME_ZONE:
+            # When we can, attempt to validate the timezone. If we can't find
+            # this file, no check happens and it's harmless.
+            zoneinfo_root = Path("/usr/share/zoneinfo")
+            zone_info_file = zoneinfo_root.joinpath(*self.TIME_ZONE.split("/"))
+            if zoneinfo_root.exists() and not zone_info_file.exists():
+                raise ValueError("Incorrect timezone setting: %s" % self.TIME_ZONE)
+            # Move the time zone info into os.environ. See ticket #2315 for why
+            # we don't do this unconditionally (breaks Windows).
+            os.environ["TZ"] = self.TIME_ZONE
+            time.tzset()
+
+        if self.is_overridden("USE_L10N"):
+            warnings.warn(USE_L10N_DEPRECATED_MSG, RemovedInDjango50Warning)
+
+    def is_overridden(self, setting):
+        return setting in self._explicit_settings
+
+    def __repr__(self):
+        return '<%(cls)s "%(settings_module)s">' % {
+            "cls": self.__class__.__name__,
+            "settings_module": self.SETTINGS_MODULE,
+        }
+
+
+class UserSettingsHolder:
+    """Holder for user configured settings."""
+
+    # SETTINGS_MODULE doesn't make much sense in the manually configured
+    # (standalone) case.
+    SETTINGS_MODULE = None
+
+    def __init__(self, default_settings):
+        """
+        Requests for configuration variables not in this class are satisfied
+        from the module specified in default_settings (if possible).
+        """
+        self.__dict__["_deleted"] = set()
+        self.default_settings = default_settings
+
+    def __getattr__(self, name):
+        if not name.isupper() or name in self._deleted:
+            raise AttributeError
+        return getattr(self.default_settings, name)
+
+    def __setattr__(self, name, value):
+        self._deleted.discard(name)
+        if name == "USE_L10N":
+            warnings.warn(USE_L10N_DEPRECATED_MSG, RemovedInDjango50Warning)
+        if name == "CSRF_COOKIE_MASKED":
+            warnings.warn(CSRF_COOKIE_MASKED_DEPRECATED_MSG, RemovedInDjango50Warning)
+        super().__setattr__(name, value)
+        if name == "USE_DEPRECATED_PYTZ":
+            warnings.warn(USE_DEPRECATED_PYTZ_DEPRECATED_MSG, RemovedInDjango50Warning)
+
+    def __delattr__(self, name):
+        self._deleted.add(name)
+        if hasattr(self, name):
+            super().__delattr__(name)
+
+    def __dir__(self):
+        return sorted(
+            s
+            for s in [*self.__dict__, *dir(self.default_settings)]
+            if s not in self._deleted
+        )
+
+    def is_overridden(self, setting):
+        deleted = setting in self._deleted
+        set_locally = setting in self.__dict__
+        set_on_default = getattr(
+            self.default_settings, "is_overridden", lambda s: False
+        )(setting)
+        return deleted or set_locally or set_on_default
+
+    def __repr__(self):
+        return "<%(cls)s>" % {
+            "cls": self.__class__.__name__,
+        }
+
+
+settings = LazySettings()

env/lib/python3.8/site-packages/django/conf/app_template/admin.py-tpl

@@ -0,0 +1,3 @@
+from django.contrib import admin
+
+# Register your models here.

env/lib/python3.8/site-packages/django/conf/app_template/apps.py-tpl

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class {{ camel_case_app_name }}Config(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = '{{ app_name }}'

env/lib/python3.8/site-packages/django/conf/app_template/models.py-tpl

@@ -0,0 +1,3 @@
+from django.db import models
+
+# Create your models here.

env/lib/python3.8/site-packages/django/conf/app_template/tests.py-tpl

@@ -0,0 +1,3 @@
+from django.test import TestCase
+
+# Create your tests here.

env/lib/python3.8/site-packages/django/conf/app_template/views.py-tpl

@@ -0,0 +1,3 @@
+from django.shortcuts import render
+
+# Create your views here.

env/lib/python3.8/site-packages/django/conf/global_settings.py

@@ -0,0 +1,667 @@
+"""
+Default Django settings. Override these with settings in the module pointed to
+by the DJANGO_SETTINGS_MODULE environment variable.
+"""
+
+
+# This is defined here as a do-nothing function because we can't import
+# django.utils.translation -- that module depends on the settings.
+def gettext_noop(s):
+    return s
+
+
+####################
+# CORE             #
+####################
+
+DEBUG = False
+
+# Whether the framework should propagate raw exceptions rather than catching
+# them. This is useful under some testing situations and should never be used
+# on a live site.
+DEBUG_PROPAGATE_EXCEPTIONS = False
+
+# People who get code error notifications. In the format
+# [('Full Name', 'email@example.com'), ('Full Name', 'anotheremail@example.com')]
+ADMINS = []
+
+# List of IP addresses, as strings, that:
+#   * See debug comments, when DEBUG is true
+#   * Receive x-headers
+INTERNAL_IPS = []
+
+# Hosts/domain names that are valid for this site.
+# "*" matches anything, ".example.com" matches example.com and all subdomains
+ALLOWED_HOSTS = []
+
+# Local time zone for this installation. All choices can be found here:
+# https://en.wikipedia.org/wiki/List_of_tz_zones_by_name (although not all
+# systems may support all possibilities). When USE_TZ is True, this is
+# interpreted as the default user time zone.
+TIME_ZONE = "America/Chicago"
+
+# If you set this to True, Django will use timezone-aware datetimes.
+USE_TZ = False
+
+# RemovedInDjango50Warning: It's a transitional setting helpful in migrating
+# from pytz tzinfo to ZoneInfo(). Set True to continue using pytz tzinfo
+# objects during the Django 4.x release cycle.
+USE_DEPRECATED_PYTZ = False
+
+# Language code for this installation. All choices can be found here:
+# http://www.i18nguy.com/unicode/language-identifiers.html
+LANGUAGE_CODE = "en-us"
+
+# Languages we provide translations for, out of the box.
+LANGUAGES = [
+    ("af", gettext_noop("Afrikaans")),
+    ("ar", gettext_noop("Arabic")),
+    ("ar-dz", gettext_noop("Algerian Arabic")),
+    ("ast", gettext_noop("Asturian")),
+    ("az", gettext_noop("Azerbaijani")),
+    ("bg", gettext_noop("Bulgarian")),
+    ("be", gettext_noop("Belarusian")),
+    ("bn", gettext_noop("Bengali")),
+    ("br", gettext_noop("Breton")),
+    ("bs", gettext_noop("Bosnian")),
+    ("ca", gettext_noop("Catalan")),
+    ("cs", gettext_noop("Czech")),
+    ("cy", gettext_noop("Welsh")),
+    ("da", gettext_noop("Danish")),
+    ("de", gettext_noop("German")),
+    ("dsb", gettext_noop("Lower Sorbian")),
+    ("el", gettext_noop("Greek")),
+    ("en", gettext_noop("English")),
+    ("en-au", gettext_noop("Australian English")),
+    ("en-gb", gettext_noop("British English")),
+    ("eo", gettext_noop("Esperanto")),
+    ("es", gettext_noop("Spanish")),
+    ("es-ar", gettext_noop("Argentinian Spanish")),
+    ("es-co", gettext_noop("Colombian Spanish")),
+    ("es-mx", gettext_noop("Mexican Spanish")),
+    ("es-ni", gettext_noop("Nicaraguan Spanish")),
+    ("es-ve", gettext_noop("Venezuelan Spanish")),
+    ("et", gettext_noop("Estonian")),
+    ("eu", gettext_noop("Basque")),
+    ("fa", gettext_noop("Persian")),
+    ("fi", gettext_noop("Finnish")),
+    ("fr", gettext_noop("French")),
+    ("fy", gettext_noop("Frisian")),
+    ("ga", gettext_noop("Irish")),
+    ("gd", gettext_noop("Scottish Gaelic")),
+    ("gl", gettext_noop("Galician")),
+    ("he", gettext_noop("Hebrew")),
+    ("hi", gettext_noop("Hindi")),
+    ("hr", gettext_noop("Croatian")),
+    ("hsb", gettext_noop("Upper Sorbian")),
+    ("hu", gettext_noop("Hungarian")),
+    ("hy", gettext_noop("Armenian")),
+    ("ia", gettext_noop("Interlingua")),
+    ("id", gettext_noop("Indonesian")),
+    ("ig", gettext_noop("Igbo")),
+    ("io", gettext_noop("Ido")),
+    ("is", gettext_noop("Icelandic")),
+    ("it", gettext_noop("Italian")),
+    ("ja", gettext_noop("Japanese")),
+    ("ka", gettext_noop("Georgian")),
+    ("kab", gettext_noop("Kabyle")),
+    ("kk", gettext_noop("Kazakh")),
+    ("km", gettext_noop("Khmer")),
+    ("kn", gettext_noop("Kannada")),
+    ("ko", gettext_noop("Korean")),
+    ("ky", gettext_noop("Kyrgyz")),
+    ("lb", gettext_noop("Luxembourgish")),
+    ("lt", gettext_noop("Lithuanian")),
+    ("lv", gettext_noop("Latvian")),
+    ("mk", gettext_noop("Macedonian")),
+    ("ml", gettext_noop("Malayalam")),
+    ("mn", gettext_noop("Mongolian")),
+    ("mr", gettext_noop("Marathi")),
+    ("ms", gettext_noop("Malay")),
+    ("my", gettext_noop("Burmese")),
+    ("nb", gettext_noop("Norwegian Bokmål")),
+    ("ne", gettext_noop("Nepali")),
+    ("nl", gettext_noop("Dutch")),
+    ("nn", gettext_noop("Norwegian Nynorsk")),
+    ("os", gettext_noop("Ossetic")),
+    ("pa", gettext_noop("Punjabi")),
+    ("pl", gettext_noop("Polish")),
+    ("pt", gettext_noop("Portuguese")),
+    ("pt-br", gettext_noop("Brazilian Portuguese")),
+    ("ro", gettext_noop("Romanian")),
+    ("ru", gettext_noop("Russian")),
+    ("sk", gettext_noop("Slovak")),
+    ("sl", gettext_noop("Slovenian")),
+    ("sq", gettext_noop("Albanian")),
+    ("sr", gettext_noop("Serbian")),
+    ("sr-latn", gettext_noop("Serbian Latin")),
+    ("sv", gettext_noop("Swedish")),
+    ("sw", gettext_noop("Swahili")),
+    ("ta", gettext_noop("Tamil")),
+    ("te", gettext_noop("Telugu")),
+    ("tg", gettext_noop("Tajik")),
+    ("th", gettext_noop("Thai")),
+    ("tk", gettext_noop("Turkmen")),
+    ("tr", gettext_noop("Turkish")),
+    ("tt", gettext_noop("Tatar")),
+    ("udm", gettext_noop("Udmurt")),
+    ("uk", gettext_noop("Ukrainian")),
+    ("ur", gettext_noop("Urdu")),
+    ("uz", gettext_noop("Uzbek")),
+    ("vi", gettext_noop("Vietnamese")),
+    ("zh-hans", gettext_noop("Simplified Chinese")),
+    ("zh-hant", gettext_noop("Traditional Chinese")),
+]
+
+# Languages using BiDi (right-to-left) layout
+LANGUAGES_BIDI = ["he", "ar", "ar-dz", "fa", "ur"]
+
+# If you set this to False, Django will make some optimizations so as not
+# to load the internationalization machinery.
+USE_I18N = True
+LOCALE_PATHS = []
+
+# Settings for language cookie
+LANGUAGE_COOKIE_NAME = "django_language"
+LANGUAGE_COOKIE_AGE = None
+LANGUAGE_COOKIE_DOMAIN = None
+LANGUAGE_COOKIE_PATH = "/"
+LANGUAGE_COOKIE_SECURE = False
+LANGUAGE_COOKIE_HTTPONLY = False
+LANGUAGE_COOKIE_SAMESITE = None
+
+
+# If you set this to True, Django will format dates, numbers and calendars
+# according to user current locale.
+USE_L10N = True
+
+# Not-necessarily-technical managers of the site. They get broken link
+# notifications and other various emails.
+MANAGERS = ADMINS
+
+# Default charset to use for all HttpResponse objects, if a MIME type isn't
+# manually specified. It's used to construct the Content-Type header.
+DEFAULT_CHARSET = "utf-8"
+
+# Email address that error messages come from.
+SERVER_EMAIL = "root@localhost"
+
+# Database connection info. If left empty, will default to the dummy backend.
+DATABASES = {}
+
+# Classes used to implement DB routing behavior.
+DATABASE_ROUTERS = []
+
+# The email backend to use. For possible shortcuts see django.core.mail.
+# The default is to use the SMTP backend.
+# Third-party backends can be specified by providing a Python path
+# to a module that defines an EmailBackend class.
+EMAIL_BACKEND = "django.core.mail.backends.smtp.EmailBackend"
+
+# Host for sending email.
+EMAIL_HOST = "localhost"
+
+# Port for sending email.
+EMAIL_PORT = 25
+
+# Whether to send SMTP 'Date' header in the local time zone or in UTC.
+EMAIL_USE_LOCALTIME = False
+
+# Optional SMTP authentication information for EMAIL_HOST.
+EMAIL_HOST_USER = ""
+EMAIL_HOST_PASSWORD = ""
+EMAIL_USE_TLS = False
+EMAIL_USE_SSL = False
+EMAIL_SSL_CERTFILE = None
+EMAIL_SSL_KEYFILE = None
+EMAIL_TIMEOUT = None
+
+# List of strings representing installed apps.
+INSTALLED_APPS = []
+
+TEMPLATES = []
+
+# Default form rendering class.
+FORM_RENDERER = "django.forms.renderers.DjangoTemplates"
+
+# Default email address to use for various automated correspondence from
+# the site managers.
+DEFAULT_FROM_EMAIL = "webmaster@localhost"
+
+# Subject-line prefix for email messages send with django.core.mail.mail_admins
+# or ...mail_managers.  Make sure to include the trailing space.
+EMAIL_SUBJECT_PREFIX = "[Django] "
+
+# Whether to append trailing slashes to URLs.
+APPEND_SLASH = True
+
+# Whether to prepend the "www." subdomain to URLs that don't have it.
+PREPEND_WWW = False
+
+# Override the server-derived value of SCRIPT_NAME
+FORCE_SCRIPT_NAME = None
+
+# List of compiled regular expression objects representing User-Agent strings
+# that are not allowed to visit any page, systemwide. Use this for bad
+# robots/crawlers. Here are a few examples:
+#     import re
+#     DISALLOWED_USER_AGENTS = [
+#         re.compile(r'^NaverBot.*'),
+#         re.compile(r'^EmailSiphon.*'),
+#         re.compile(r'^SiteSucker.*'),
+#         re.compile(r'^sohu-search'),
+#     ]
+DISALLOWED_USER_AGENTS = []
+
+ABSOLUTE_URL_OVERRIDES = {}
+
+# List of compiled regular expression objects representing URLs that need not
+# be reported by BrokenLinkEmailsMiddleware. Here are a few examples:
+#    import re
+#    IGNORABLE_404_URLS = [
+#        re.compile(r'^/apple-touch-icon.*\.png$'),
+#        re.compile(r'^/favicon.ico$'),
+#        re.compile(r'^/robots.txt$'),
+#        re.compile(r'^/phpmyadmin/'),
+#        re.compile(r'\.(cgi|php|pl)$'),
+#    ]
+IGNORABLE_404_URLS = []
+
+# A secret key for this particular Django installation. Used in secret-key
+# hashing algorithms. Set this in your settings, or Django will complain
+# loudly.
+SECRET_KEY = ""
+
+# List of secret keys used to verify the validity of signatures. This allows
+# secret key rotation.
+SECRET_KEY_FALLBACKS = []
+
+# Default file storage mechanism that holds media.
+DEFAULT_FILE_STORAGE = "django.core.files.storage.FileSystemStorage"
+
+# Absolute filesystem path to the directory that will hold user-uploaded files.
+# Example: "/var/www/example.com/media/"
+MEDIA_ROOT = ""
+
+# URL that handles the media served from MEDIA_ROOT.
+# Examples: "http://example.com/media/", "http://media.example.com/"
+MEDIA_URL = ""
+
+# Absolute path to the directory static files should be collected to.
+# Example: "/var/www/example.com/static/"
+STATIC_ROOT = None
+
+# URL that handles the static files served from STATIC_ROOT.
+# Example: "http://example.com/static/", "http://static.example.com/"
+STATIC_URL = None
+
+# List of upload handler classes to be applied in order.
+FILE_UPLOAD_HANDLERS = [
+    "django.core.files.uploadhandler.MemoryFileUploadHandler",
+    "django.core.files.uploadhandler.TemporaryFileUploadHandler",
+]
+
+# Maximum size, in bytes, of a request before it will be streamed to the
+# file system instead of into memory.
+FILE_UPLOAD_MAX_MEMORY_SIZE = 2621440  # i.e. 2.5 MB
+
+# Maximum size in bytes of request data (excluding file uploads) that will be
+# read before a SuspiciousOperation (RequestDataTooBig) is raised.
+DATA_UPLOAD_MAX_MEMORY_SIZE = 2621440  # i.e. 2.5 MB
+
+# Maximum number of GET/POST parameters that will be read before a
+# SuspiciousOperation (TooManyFieldsSent) is raised.
+DATA_UPLOAD_MAX_NUMBER_FIELDS = 1000
+
+# Directory in which upload streamed files will be temporarily saved. A value of
+# `None` will make Django use the operating system's default temporary directory
+# (i.e. "/tmp" on *nix systems).
+FILE_UPLOAD_TEMP_DIR = None
+
+# The numeric mode to set newly-uploaded files to. The value should be a mode
+# you'd pass directly to os.chmod; see
+# https://docs.python.org/library/os.html#files-and-directories.
+FILE_UPLOAD_PERMISSIONS = 0o644
+
+# The numeric mode to assign to newly-created directories, when uploading files.
+# The value should be a mode as you'd pass to os.chmod;
+# see https://docs.python.org/library/os.html#files-and-directories.
+FILE_UPLOAD_DIRECTORY_PERMISSIONS = None
+
+# Python module path where user will place custom format definition.
+# The directory where this setting is pointing should contain subdirectories
+# named as the locales, containing a formats.py file
+# (i.e. "myproject.locale" for myproject/locale/en/formats.py etc. use)
+FORMAT_MODULE_PATH = None
+
+# Default formatting for date objects. See all available format strings here:
+# https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date
+DATE_FORMAT = "N j, Y"
+
+# Default formatting for datetime objects. See all available format strings here:
+# https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date
+DATETIME_FORMAT = "N j, Y, P"
+
+# Default formatting for time objects. See all available format strings here:
+# https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date
+TIME_FORMAT = "P"
+
+# Default formatting for date objects when only the year and month are relevant.
+# See all available format strings here:
+# https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date
+YEAR_MONTH_FORMAT = "F Y"
+
+# Default formatting for date objects when only the month and day are relevant.
+# See all available format strings here:
+# https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date
+MONTH_DAY_FORMAT = "F j"
+
+# Default short formatting for date objects. See all available format strings here:
+# https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date
+SHORT_DATE_FORMAT = "m/d/Y"
+
+# Default short formatting for datetime objects.
+# See all available format strings here:
+# https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date
+SHORT_DATETIME_FORMAT = "m/d/Y P"
+
+# Default formats to be used when parsing dates from input boxes, in order
+# See all available format string here:
+# https://docs.python.org/library/datetime.html#strftime-behavior
+# * Note that these format strings are different from the ones to display dates
+DATE_INPUT_FORMATS = [
+    "%Y-%m-%d",  # '2006-10-25'
+    "%m/%d/%Y",  # '10/25/2006'
+    "%m/%d/%y",  # '10/25/06'
+    "%b %d %Y",  # 'Oct 25 2006'
+    "%b %d, %Y",  # 'Oct 25, 2006'
+    "%d %b %Y",  # '25 Oct 2006'
+    "%d %b, %Y",  # '25 Oct, 2006'
+    "%B %d %Y",  # 'October 25 2006'
+    "%B %d, %Y",  # 'October 25, 2006'
+    "%d %B %Y",  # '25 October 2006'
+    "%d %B, %Y",  # '25 October, 2006'
+]
+
+# Default formats to be used when parsing times from input boxes, in order
+# See all available format string here:
+# https://docs.python.org/library/datetime.html#strftime-behavior
+# * Note that these format strings are different from the ones to display dates
+TIME_INPUT_FORMATS = [
+    "%H:%M:%S",  # '14:30:59'
+    "%H:%M:%S.%f",  # '14:30:59.000200'
+    "%H:%M",  # '14:30'
+]
+
+# Default formats to be used when parsing dates and times from input boxes,
+# in order
+# See all available format string here:
+# https://docs.python.org/library/datetime.html#strftime-behavior
+# * Note that these format strings are different from the ones to display dates
+DATETIME_INPUT_FORMATS = [
+    "%Y-%m-%d %H:%M:%S",  # '2006-10-25 14:30:59'
+    "%Y-%m-%d %H:%M:%S.%f",  # '2006-10-25 14:30:59.000200'
+    "%Y-%m-%d %H:%M",  # '2006-10-25 14:30'
+    "%m/%d/%Y %H:%M:%S",  # '10/25/2006 14:30:59'
+    "%m/%d/%Y %H:%M:%S.%f",  # '10/25/2006 14:30:59.000200'
+    "%m/%d/%Y %H:%M",  # '10/25/2006 14:30'
+    "%m/%d/%y %H:%M:%S",  # '10/25/06 14:30:59'
+    "%m/%d/%y %H:%M:%S.%f",  # '10/25/06 14:30:59.000200'
+    "%m/%d/%y %H:%M",  # '10/25/06 14:30'
+]
+
+# First day of week, to be used on calendars
+# 0 means Sunday, 1 means Monday...
+FIRST_DAY_OF_WEEK = 0
+
+# Decimal separator symbol
+DECIMAL_SEPARATOR = "."
+
+# Boolean that sets whether to add thousand separator when formatting numbers
+USE_THOUSAND_SEPARATOR = False
+
+# Number of digits that will be together, when splitting them by
+# THOUSAND_SEPARATOR. 0 means no grouping, 3 means splitting by thousands...
+NUMBER_GROUPING = 0
+
+# Thousand separator symbol
+THOUSAND_SEPARATOR = ","
+
+# The tablespaces to use for each model when not specified otherwise.
+DEFAULT_TABLESPACE = ""
+DEFAULT_INDEX_TABLESPACE = ""
+
+# Default primary key field type.
+DEFAULT_AUTO_FIELD = "django.db.models.AutoField"
+
+# Default X-Frame-Options header value
+X_FRAME_OPTIONS = "DENY"
+
+USE_X_FORWARDED_HOST = False
+USE_X_FORWARDED_PORT = False
+
+# The Python dotted path to the WSGI application that Django's internal server
+# (runserver) will use. If `None`, the return value of
+# 'django.core.wsgi.get_wsgi_application' is used, thus preserving the same
+# behavior as previous versions of Django. Otherwise this should point to an
+# actual WSGI application object.
+WSGI_APPLICATION = None
+
+# If your Django app is behind a proxy that sets a header to specify secure
+# connections, AND that proxy ensures that user-submitted headers with the
+# same name are ignored (so that people can't spoof it), set this value to
+# a tuple of (header_name, header_value). For any requests that come in with
+# that header/value, request.is_secure() will return True.
+# WARNING! Only set this if you fully understand what you're doing. Otherwise,
+# you may be opening yourself up to a security risk.
+SECURE_PROXY_SSL_HEADER = None
+
+##############
+# MIDDLEWARE #
+##############
+
+# List of middleware to use. Order is important; in the request phase, these
+# middleware will be applied in the order given, and in the response
+# phase the middleware will be applied in reverse order.
+MIDDLEWARE = []
+
+############
+# SESSIONS #
+############
+
+# Cache to store session data if using the cache session backend.
+SESSION_CACHE_ALIAS = "default"
+# Cookie name. This can be whatever you want.
+SESSION_COOKIE_NAME = "sessionid"
+# Age of cookie, in seconds (default: 2 weeks).
+SESSION_COOKIE_AGE = 60 * 60 * 24 * 7 * 2
+# A string like "example.com", or None for standard domain cookie.
+SESSION_COOKIE_DOMAIN = None
+# Whether the session cookie should be secure (https:// only).
+SESSION_COOKIE_SECURE = False
+# The path of the session cookie.
+SESSION_COOKIE_PATH = "/"
+# Whether to use the HttpOnly flag.
+SESSION_COOKIE_HTTPONLY = True
+# Whether to set the flag restricting cookie leaks on cross-site requests.
+# This can be 'Lax', 'Strict', 'None', or False to disable the flag.
+SESSION_COOKIE_SAMESITE = "Lax"
+# Whether to save the session data on every request.
+SESSION_SAVE_EVERY_REQUEST = False
+# Whether a user's session cookie expires when the web browser is closed.
+SESSION_EXPIRE_AT_BROWSER_CLOSE = False
+# The module to store session data
+SESSION_ENGINE = "django.contrib.sessions.backends.db"
+# Directory to store session files if using the file session module. If None,
+# the backend will use a sensible default.
+SESSION_FILE_PATH = None
+# class to serialize session data
+SESSION_SERIALIZER = "django.contrib.sessions.serializers.JSONSerializer"
+
+#########
+# CACHE #
+#########
+
+# The cache backends to use.
+CACHES = {
+    "default": {
+        "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
+    }
+}
+CACHE_MIDDLEWARE_KEY_PREFIX = ""
+CACHE_MIDDLEWARE_SECONDS = 600
+CACHE_MIDDLEWARE_ALIAS = "default"
+
+##################
+# AUTHENTICATION #
+##################
+
+AUTH_USER_MODEL = "auth.User"
+
+AUTHENTICATION_BACKENDS = ["django.contrib.auth.backends.ModelBackend"]
+
+LOGIN_URL = "/accounts/login/"
+
+LOGIN_REDIRECT_URL = "/accounts/profile/"
+
+LOGOUT_REDIRECT_URL = None
+
+# The number of seconds a password reset link is valid for (default: 3 days).
+PASSWORD_RESET_TIMEOUT = 60 * 60 * 24 * 3
+
+# the first hasher in this list is the preferred algorithm.  any
+# password using different algorithms will be converted automatically
+# upon login
+PASSWORD_HASHERS = [
+    "django.contrib.auth.hashers.PBKDF2PasswordHasher",
+    "django.contrib.auth.hashers.PBKDF2SHA1PasswordHasher",
+    "django.contrib.auth.hashers.Argon2PasswordHasher",
+    "django.contrib.auth.hashers.BCryptSHA256PasswordHasher",
+    "django.contrib.auth.hashers.ScryptPasswordHasher",
+]
+
+AUTH_PASSWORD_VALIDATORS = []
+
+###########
+# SIGNING #
+###########
+
+SIGNING_BACKEND = "django.core.signing.TimestampSigner"
+
+########
+# CSRF #
+########
+
+# Dotted path to callable to be used as view when a request is
+# rejected by the CSRF middleware.
+CSRF_FAILURE_VIEW = "django.views.csrf.csrf_failure"
+
+# Settings for CSRF cookie.
+CSRF_COOKIE_NAME = "csrftoken"
+CSRF_COOKIE_AGE = 60 * 60 * 24 * 7 * 52
+CSRF_COOKIE_DOMAIN = None
+CSRF_COOKIE_PATH = "/"
+CSRF_COOKIE_SECURE = False
+CSRF_COOKIE_HTTPONLY = False
+CSRF_COOKIE_SAMESITE = "Lax"
+CSRF_HEADER_NAME = "HTTP_X_CSRFTOKEN"
+CSRF_TRUSTED_ORIGINS = []
+CSRF_USE_SESSIONS = False
+
+# Whether to mask CSRF cookie value. It's a transitional setting helpful in
+# migrating multiple instance of the same project to Django 4.1+.
+CSRF_COOKIE_MASKED = False
+
+############
+# MESSAGES #
+############
+
+# Class to use as messages backend
+MESSAGE_STORAGE = "django.contrib.messages.storage.fallback.FallbackStorage"
+
+# Default values of MESSAGE_LEVEL and MESSAGE_TAGS are defined within
+# django.contrib.messages to avoid imports in this settings file.
+
+###########
+# LOGGING #
+###########
+
+# The callable to use to configure logging
+LOGGING_CONFIG = "logging.config.dictConfig"
+
+# Custom logging configuration.
+LOGGING = {}
+
+# Default exception reporter class used in case none has been
+# specifically assigned to the HttpRequest instance.
+DEFAULT_EXCEPTION_REPORTER = "django.views.debug.ExceptionReporter"
+
+# Default exception reporter filter class used in case none has been
+# specifically assigned to the HttpRequest instance.
+DEFAULT_EXCEPTION_REPORTER_FILTER = "django.views.debug.SafeExceptionReporterFilter"
+
+###########
+# TESTING #
+###########
+
+# The name of the class to use to run the test suite
+TEST_RUNNER = "django.test.runner.DiscoverRunner"
+
+# Apps that don't need to be serialized at test database creation time
+# (only apps with migrations are to start with)
+TEST_NON_SERIALIZED_APPS = []
+
+############
+# FIXTURES #
+############
+
+# The list of directories to search for fixtures
+FIXTURE_DIRS = []
+
+###############
+# STATICFILES #
+###############
+
+# A list of locations of additional static files
+STATICFILES_DIRS = []
+
+# The default file storage backend used during the build process
+STATICFILES_STORAGE = "django.contrib.staticfiles.storage.StaticFilesStorage"
+
+# List of finder classes that know how to find static files in
+# various locations.
+STATICFILES_FINDERS = [
+    "django.contrib.staticfiles.finders.FileSystemFinder",
+    "django.contrib.staticfiles.finders.AppDirectoriesFinder",
+    # 'django.contrib.staticfiles.finders.DefaultStorageFinder',
+]
+
+##############
+# MIGRATIONS #
+##############
+
+# Migration module overrides for apps, by app label.
+MIGRATION_MODULES = {}
+
+#################
+# SYSTEM CHECKS #
+#################
+
+# List of all issues generated by system checks that should be silenced. Light
+# issues like warnings, infos or debugs will not generate a message. Silencing
+# serious issues like errors and criticals does not result in hiding the
+# message, but Django will not stop you from e.g. running server.
+SILENCED_SYSTEM_CHECKS = []
+
+#######################
+# SECURITY MIDDLEWARE #
+#######################
+SECURE_CONTENT_TYPE_NOSNIFF = True
+SECURE_CROSS_ORIGIN_OPENER_POLICY = "same-origin"
+SECURE_HSTS_INCLUDE_SUBDOMAINS = False
+SECURE_HSTS_PRELOAD = False
+SECURE_HSTS_SECONDS = 0
+SECURE_REDIRECT_EXEMPT = []
+SECURE_REFERRER_POLICY = "same-origin"
+SECURE_SSL_HOST = None
+SECURE_SSL_REDIRECT = False

env/lib/python3.8/site-packages/django/conf/locale/__init__.py

@@ -0,0 +1,617 @@
+"""
+LANG_INFO is a dictionary structure to provide meta information about languages.
+
+About name_local: capitalize it as if your language name was appearing
+inside a sentence in your language.
+The 'fallback' key can be used to specify a special fallback logic which doesn't
+follow the traditional 'fr-ca' -> 'fr' fallback logic.
+"""
+
+LANG_INFO = {
+    "af": {
+        "bidi": False,
+        "code": "af",
+        "name": "Afrikaans",
+        "name_local": "Afrikaans",
+    },
+    "ar": {
+        "bidi": True,
+        "code": "ar",
+        "name": "Arabic",
+        "name_local": "العربيّة",
+    },
+    "ar-dz": {
+        "bidi": True,
+        "code": "ar-dz",
+        "name": "Algerian Arabic",
+        "name_local": "العربية الجزائرية",
+    },
+    "ast": {
+        "bidi": False,
+        "code": "ast",
+        "name": "Asturian",
+        "name_local": "asturianu",
+    },
+    "az": {
+        "bidi": True,
+        "code": "az",
+        "name": "Azerbaijani",
+        "name_local": "Azərbaycanca",
+    },
+    "be": {
+        "bidi": False,
+        "code": "be",
+        "name": "Belarusian",
+        "name_local": "беларуская",
+    },
+    "bg": {
+        "bidi": False,
+        "code": "bg",
+        "name": "Bulgarian",
+        "name_local": "български",
+    },
+    "bn": {
+        "bidi": False,
+        "code": "bn",
+        "name": "Bengali",
+        "name_local": "বাংলা",
+    },
+    "br": {
+        "bidi": False,
+        "code": "br",
+        "name": "Breton",
+        "name_local": "brezhoneg",
+    },
+    "bs": {
+        "bidi": False,
+        "code": "bs",
+        "name": "Bosnian",
+        "name_local": "bosanski",
+    },
+    "ca": {
+        "bidi": False,
+        "code": "ca",
+        "name": "Catalan",
+        "name_local": "català",
+    },
+    "cs": {
+        "bidi": False,
+        "code": "cs",
+        "name": "Czech",
+        "name_local": "česky",
+    },
+    "cy": {
+        "bidi": False,
+        "code": "cy",
+        "name": "Welsh",
+        "name_local": "Cymraeg",
+    },
+    "da": {
+        "bidi": False,
+        "code": "da",
+        "name": "Danish",
+        "name_local": "dansk",
+    },
+    "de": {
+        "bidi": False,
+        "code": "de",
+        "name": "German",
+        "name_local": "Deutsch",
+    },
+    "dsb": {
+        "bidi": False,
+        "code": "dsb",
+        "name": "Lower Sorbian",
+        "name_local": "dolnoserbski",
+    },
+    "el": {
+        "bidi": False,
+        "code": "el",
+        "name": "Greek",
+        "name_local": "Ελληνικά",
+    },
+    "en": {
+        "bidi": False,
+        "code": "en",
+        "name": "English",
+        "name_local": "English",
+    },
+    "en-au": {
+        "bidi": False,
+        "code": "en-au",
+        "name": "Australian English",
+        "name_local": "Australian English",
+    },
+    "en-gb": {
+        "bidi": False,
+        "code": "en-gb",
+        "name": "British English",
+        "name_local": "British English",
+    },
+    "eo": {
+        "bidi": False,
+        "code": "eo",
+        "name": "Esperanto",
+        "name_local": "Esperanto",
+    },
+    "es": {
+        "bidi": False,
+        "code": "es",
+        "name": "Spanish",
+        "name_local": "español",
+    },
+    "es-ar": {
+        "bidi": False,
+        "code": "es-ar",
+        "name": "Argentinian Spanish",
+        "name_local": "español de Argentina",
+    },
+    "es-co": {
+        "bidi": False,
+        "code": "es-co",
+        "name": "Colombian Spanish",
+        "name_local": "español de Colombia",
+    },
+    "es-mx": {
+        "bidi": False,
+        "code": "es-mx",
+        "name": "Mexican Spanish",
+        "name_local": "español de Mexico",
+    },
+    "es-ni": {
+        "bidi": False,
+        "code": "es-ni",
+        "name": "Nicaraguan Spanish",
+        "name_local": "español de Nicaragua",
+    },
+    "es-ve": {
+        "bidi": False,
+        "code": "es-ve",
+        "name": "Venezuelan Spanish",
+        "name_local": "español de Venezuela",
+    },
+    "et": {
+        "bidi": False,
+        "code": "et",
+        "name": "Estonian",
+        "name_local": "eesti",
+    },
+    "eu": {
+        "bidi": False,
+        "code": "eu",
+        "name": "Basque",
+        "name_local": "Basque",
+    },
+    "fa": {
+        "bidi": True,
+        "code": "fa",
+        "name": "Persian",
+        "name_local": "فارسی",
+    },
+    "fi": {
+        "bidi": False,
+        "code": "fi",
+        "name": "Finnish",
+        "name_local": "suomi",
+    },
+    "fr": {
+        "bidi": False,
+        "code": "fr",
+        "name": "French",
+        "name_local": "français",
+    },
+    "fy": {
+        "bidi": False,
+        "code": "fy",
+        "name": "Frisian",
+        "name_local": "frysk",
+    },
+    "ga": {
+        "bidi": False,
+        "code": "ga",
+        "name": "Irish",
+        "name_local": "Gaeilge",
+    },
+    "gd": {
+        "bidi": False,
+        "code": "gd",
+        "name": "Scottish Gaelic",
+        "name_local": "Gàidhlig",
+    },
+    "gl": {
+        "bidi": False,
+        "code": "gl",
+        "name": "Galician",
+        "name_local": "galego",
+    },
+    "he": {
+        "bidi": True,
+        "code": "he",
+        "name": "Hebrew",
+        "name_local": "עברית",
+    },
+    "hi": {
+        "bidi": False,
+        "code": "hi",
+        "name": "Hindi",
+        "name_local": "हिंदी",
+    },
+    "hr": {
+        "bidi": False,
+        "code": "hr",
+        "name": "Croatian",
+        "name_local": "Hrvatski",
+    },
+    "hsb": {
+        "bidi": False,
+        "code": "hsb",
+        "name": "Upper Sorbian",
+        "name_local": "hornjoserbsce",
+    },
+    "hu": {
+        "bidi": False,
+        "code": "hu",
+        "name": "Hungarian",
+        "name_local": "Magyar",
+    },
+    "hy": {
+        "bidi": False,
+        "code": "hy",
+        "name": "Armenian",
+        "name_local": "հայերեն",
+    },
+    "ia": {
+        "bidi": False,
+        "code": "ia",
+        "name": "Interlingua",
+        "name_local": "Interlingua",
+    },
+    "io": {
+        "bidi": False,
+        "code": "io",
+        "name": "Ido",
+        "name_local": "ido",
+    },
+    "id": {
+        "bidi": False,
+        "code": "id",
+        "name": "Indonesian",
+        "name_local": "Bahasa Indonesia",
+    },
+    "ig": {
+        "bidi": False,
+        "code": "ig",
+        "name": "Igbo",
+        "name_local": "Asụsụ Ìgbò",
+    },
+    "is": {
+        "bidi": False,
+        "code": "is",
+        "name": "Icelandic",
+        "name_local": "Íslenska",
+    },
+    "it": {
+        "bidi": False,
+        "code": "it",
+        "name": "Italian",
+        "name_local": "italiano",
+    },
+    "ja": {
+        "bidi": False,
+        "code": "ja",
+        "name": "Japanese",
+        "name_local": "日本語",
+    },
+    "ka": {
+        "bidi": False,
+        "code": "ka",
+        "name": "Georgian",
+        "name_local": "ქართული",
+    },
+    "kab": {
+        "bidi": False,
+        "code": "kab",
+        "name": "Kabyle",
+        "name_local": "taqbaylit",
+    },
+    "kk": {
+        "bidi": False,
+        "code": "kk",
+        "name": "Kazakh",
+        "name_local": "Қазақ",
+    },
+    "km": {
+        "bidi": False,
+        "code": "km",
+        "name": "Khmer",
+        "name_local": "Khmer",
+    },
+    "kn": {
+        "bidi": False,
+        "code": "kn",
+        "name": "Kannada",
+        "name_local": "Kannada",
+    },
+    "ko": {
+        "bidi": False,
+        "code": "ko",
+        "name": "Korean",
+        "name_local": "한국어",
+    },
+    "ky": {
+        "bidi": False,
+        "code": "ky",
+        "name": "Kyrgyz",
+        "name_local": "Кыргызча",
+    },
+    "lb": {
+        "bidi": False,
+        "code": "lb",
+        "name": "Luxembourgish",
+        "name_local": "Lëtzebuergesch",
+    },
+    "lt": {
+        "bidi": False,
+        "code": "lt",
+        "name": "Lithuanian",
+        "name_local": "Lietuviškai",
+    },
+    "lv": {
+        "bidi": False,
+        "code": "lv",
+        "name": "Latvian",
+        "name_local": "latviešu",
+    },
+    "mk": {
+        "bidi": False,
+        "code": "mk",
+        "name": "Macedonian",
+        "name_local": "Македонски",
+    },
+    "ml": {
+        "bidi": False,
+        "code": "ml",
+        "name": "Malayalam",
+        "name_local": "മലയാളം",
+    },
+    "mn": {
+        "bidi": False,
+        "code": "mn",
+        "name": "Mongolian",
+        "name_local": "Mongolian",
+    },
+    "mr": {
+        "bidi": False,
+        "code": "mr",
+        "name": "Marathi",
+        "name_local": "मराठी",
+    },
+    "ms": {
+        "bidi": False,
+        "code": "ms",
+        "name": "Malay",
+        "name_local": "Bahasa Melayu",
+    },
+    "my": {
+        "bidi": False,
+        "code": "my",
+        "name": "Burmese",
+        "name_local": "မြန်မာဘာသာ",
+    },
+    "nb": {
+        "bidi": False,
+        "code": "nb",
+        "name": "Norwegian Bokmal",
+        "name_local": "norsk (bokmål)",
+    },
+    "ne": {
+        "bidi": False,
+        "code": "ne",
+        "name": "Nepali",
+        "name_local": "नेपाली",
+    },
+    "nl": {
+        "bidi": False,
+        "code": "nl",
+        "name": "Dutch",
+        "name_local": "Nederlands",
+    },
+    "nn": {
+        "bidi": False,
+        "code": "nn",
+        "name": "Norwegian Nynorsk",
+        "name_local": "norsk (nynorsk)",
+    },
+    "no": {
+        "bidi": False,
+        "code": "no",
+        "name": "Norwegian",
+        "name_local": "norsk",
+    },
+    "os": {
+        "bidi": False,
+        "code": "os",
+        "name": "Ossetic",
+        "name_local": "Ирон",
+    },
+    "pa": {
+        "bidi": False,
+        "code": "pa",
+        "name": "Punjabi",
+        "name_local": "Punjabi",
+    },
+    "pl": {
+        "bidi": False,
+        "code": "pl",
+        "name": "Polish",
+        "name_local": "polski",
+    },
+    "pt": {
+        "bidi": False,
+        "code": "pt",
+        "name": "Portuguese",
+        "name_local": "Português",
+    },
+    "pt-br": {
+        "bidi": False,
+        "code": "pt-br",
+        "name": "Brazilian Portuguese",
+        "name_local": "Português Brasileiro",
+    },
+    "ro": {
+        "bidi": False,
+        "code": "ro",
+        "name": "Romanian",
+        "name_local": "Română",
+    },
+    "ru": {
+        "bidi": False,
+        "code": "ru",
+        "name": "Russian",
+        "name_local": "Русский",
+    },
+    "sk": {
+        "bidi": False,
+        "code": "sk",
+        "name": "Slovak",
+        "name_local": "Slovensky",
+    },
+    "sl": {
+        "bidi": False,
+        "code": "sl",
+        "name": "Slovenian",
+        "name_local": "Slovenščina",
+    },
+    "sq": {
+        "bidi": False,
+        "code": "sq",
+        "name": "Albanian",
+        "name_local": "shqip",
+    },
+    "sr": {
+        "bidi": False,
+        "code": "sr",
+        "name": "Serbian",
+        "name_local": "српски",
+    },
+    "sr-latn": {
+        "bidi": False,
+        "code": "sr-latn",
+        "name": "Serbian Latin",
+        "name_local": "srpski (latinica)",
+    },
+    "sv": {
+        "bidi": False,
+        "code": "sv",
+        "name": "Swedish",
+        "name_local": "svenska",
+    },
+    "sw": {
+        "bidi": False,
+        "code": "sw",
+        "name": "Swahili",
+        "name_local": "Kiswahili",
+    },
+    "ta": {
+        "bidi": False,
+        "code": "ta",
+        "name": "Tamil",
+        "name_local": "தமிழ்",
+    },
+    "te": {
+        "bidi": False,
+        "code": "te",
+        "name": "Telugu",
+        "name_local": "తెలుగు",
+    },
+    "tg": {
+        "bidi": False,
+        "code": "tg",
+        "name": "Tajik",
+        "name_local": "тоҷикӣ",
+    },
+    "th": {
+        "bidi": False,
+        "code": "th",
+        "name": "Thai",
+        "name_local": "ภาษาไทย",
+    },
+    "tk": {
+        "bidi": False,
+        "code": "tk",
+        "name": "Turkmen",
+        "name_local": "Türkmençe",
+    },
+    "tr": {
+        "bidi": False,
+        "code": "tr",
+        "name": "Turkish",
+        "name_local": "Türkçe",
+    },
+    "tt": {
+        "bidi": False,
+        "code": "tt",
+        "name": "Tatar",
+        "name_local": "Татарча",
+    },
+    "udm": {
+        "bidi": False,
+        "code": "udm",
+        "name": "Udmurt",
+        "name_local": "Удмурт",
+    },
+    "uk": {
+        "bidi": False,
+        "code": "uk",
+        "name": "Ukrainian",
+        "name_local": "Українська",
+    },
+    "ur": {
+        "bidi": True,
+        "code": "ur",
+        "name": "Urdu",
+        "name_local": "اردو",
+    },
+    "uz": {
+        "bidi": False,
+        "code": "uz",
+        "name": "Uzbek",
+        "name_local": "oʻzbek tili",
+    },
+    "vi": {
+        "bidi": False,
+        "code": "vi",
+        "name": "Vietnamese",
+        "name_local": "Tiếng Việt",
+    },
+    "zh-cn": {
+        "fallback": ["zh-hans"],
+    },
+    "zh-hans": {
+        "bidi": False,
+        "code": "zh-hans",
+        "name": "Simplified Chinese",
+        "name_local": "简体中文",
+    },
+    "zh-hant": {
+        "bidi": False,
+        "code": "zh-hant",
+        "name": "Traditional Chinese",
+        "name_local": "繁體中文",
+    },
+    "zh-hk": {
+        "fallback": ["zh-hant"],
+    },
+    "zh-mo": {
+        "fallback": ["zh-hant"],
+    },
+    "zh-my": {
+        "fallback": ["zh-hans"],
+    },
+    "zh-sg": {
+        "fallback": ["zh-hans"],
+    },
+    "zh-tw": {
+        "fallback": ["zh-hant"],
+    },
+}

env/lib/python3.8/site-packages/django/conf/locale/ar/formats.py

@@ -0,0 +1,21 @@
+# This file is distributed under the same license as the Django package.
+#
+# The *_FORMAT strings use the Django date format syntax,
+# see https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date
+DATE_FORMAT = "j F، Y"
+TIME_FORMAT = "g:i A"
+# DATETIME_FORMAT =
+YEAR_MONTH_FORMAT = "F Y"
+MONTH_DAY_FORMAT = "j F"
+SHORT_DATE_FORMAT = "d‏/m‏/Y"
+# SHORT_DATETIME_FORMAT =
+# FIRST_DAY_OF_WEEK =
+
+# The *_INPUT_FORMATS strings use the Python strftime format syntax,
+# see https://docs.python.org/library/datetime.html#strftime-strptime-behavior
+# DATE_INPUT_FORMATS =
+# TIME_INPUT_FORMATS =
+# DATETIME_INPUT_FORMATS =
+DECIMAL_SEPARATOR = ","
+THOUSAND_SEPARATOR = "."
+# NUMBER_GROUPING =

env/lib/python3.8/site-packages/django/conf/locale/ar_DZ/formats.py

@@ -0,0 +1,29 @@
+# This file is distributed under the same license as the Django package.
+#
+# The *_FORMAT strings use the Django date format syntax,
+# see https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date
+DATE_FORMAT = "j F Y"
+TIME_FORMAT = "H:i"
+DATETIME_FORMAT = "j F Y H:i"
+YEAR_MONTH_FORMAT = "F Y"
+MONTH_DAY_FORMAT = "j F"
+SHORT_DATE_FORMAT = "j F Y"
+SHORT_DATETIME_FORMAT = "j F Y H:i"
+FIRST_DAY_OF_WEEK = 0  # Sunday
+
+# The *_INPUT_FORMATS strings use the Python strftime format syntax,
+# see https://docs.python.org/library/datetime.html#strftime-strptime-behavior
+DATE_INPUT_FORMATS = [
+    "%Y/%m/%d",  # '2006/10/25'
+]
+TIME_INPUT_FORMATS = [
+    "%H:%M",  # '14:30
+    "%H:%M:%S",  # '14:30:59'
+]
+DATETIME_INPUT_FORMATS = [
+    "%Y/%m/%d %H:%M",  # '2006/10/25 14:30'
+    "%Y/%m/%d %H:%M:%S",  # '2006/10/25 14:30:59'
+]
+DECIMAL_SEPARATOR = ","
+THOUSAND_SEPARATOR = "."
+NUMBER_GROUPING = 3

env/lib/python3.8/site-packages/django/conf/locale/az/formats.py

@@ -0,0 +1,30 @@
+# This file is distributed under the same license as the Django package.
+#
+# The *_FORMAT strings use the Django date format syntax,
+# see https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date
+DATE_FORMAT = "j E Y"
+TIME_FORMAT = "G:i"
+DATETIME_FORMAT = "j E Y, G:i"
+YEAR_MONTH_FORMAT = "F Y"
+MONTH_DAY_FORMAT = "j F"
+SHORT_DATE_FORMAT = "d.m.Y"
+SHORT_DATETIME_FORMAT = "d.m.Y H:i"
+FIRST_DAY_OF_WEEK = 1  # Monday
+
+# The *_INPUT_FORMATS strings use the Python strftime format syntax,
+# see https://docs.python.org/library/datetime.html#strftime-strptime-behavior
+DATE_INPUT_FORMATS = [
+    "%d.%m.%Y",  # '25.10.2006'
+    "%d.%m.%y",  # '25.10.06'
+]
+DATETIME_INPUT_FORMATS = [
+    "%d.%m.%Y %H:%M:%S",  # '25.10.2006 14:30:59'
+    "%d.%m.%Y %H:%M:%S.%f",  # '25.10.2006 14:30:59.000200'
+    "%d.%m.%Y %H:%M",  # '25.10.2006 14:30'
+    "%d.%m.%y %H:%M:%S",  # '25.10.06 14:30:59'
+    "%d.%m.%y %H:%M:%S.%f",  # '25.10.06 14:30:59.000200'
+    "%d.%m.%y %H:%M",  # '25.10.06 14:30'
+]
+DECIMAL_SEPARATOR = ","
+THOUSAND_SEPARATOR = "\xa0"  # non-breaking space
+NUMBER_GROUPING = 3

env/lib/python3.8/site-packages/django/conf/locale/bg/formats.py

@@ -0,0 +1,21 @@
+# This file is distributed under the same license as the Django package.
+#
+# The *_FORMAT strings use the Django date format syntax,
+# see https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date
+DATE_FORMAT = "d F Y"
+TIME_FORMAT = "H:i"
+# DATETIME_FORMAT =
+# YEAR_MONTH_FORMAT =
+MONTH_DAY_FORMAT = "j F"
+SHORT_DATE_FORMAT = "d.m.Y"
+# SHORT_DATETIME_FORMAT =
+# FIRST_DAY_OF_WEEK =
+
+# The *_INPUT_FORMATS strings use the Python strftime format syntax,
+# see https://docs.python.org/library/datetime.html#strftime-strptime-behavior
+# DATE_INPUT_FORMATS =
+# TIME_INPUT_FORMATS =
+# DATETIME_INPUT_FORMATS =
+DECIMAL_SEPARATOR = ","
+THOUSAND_SEPARATOR = " "  # Non-breaking space
+# NUMBER_GROUPING =

env/lib/python3.8/site-packages/django/conf/locale/bn/formats.py

@@ -0,0 +1,32 @@
+# This file is distributed under the same license as the Django package.
+#
+# The *_FORMAT strings use the Django date format syntax,
+# see https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date
+DATE_FORMAT = "j F, Y"
+TIME_FORMAT = "g:i A"
+# DATETIME_FORMAT =
+YEAR_MONTH_FORMAT = "F Y"
+MONTH_DAY_FORMAT = "j F"
+SHORT_DATE_FORMAT = "j M, Y"
+# SHORT_DATETIME_FORMAT =
+FIRST_DAY_OF_WEEK = 6  # Saturday
+
+# The *_INPUT_FORMATS strings use the Python strftime format syntax,
+# see https://docs.python.org/library/datetime.html#strftime-strptime-behavior
+DATE_INPUT_FORMATS = [
+    "%d/%m/%Y",  # 25/10/2016
+    "%d/%m/%y",  # 25/10/16
+    "%d-%m-%Y",  # 25-10-2016
+    "%d-%m-%y",  # 25-10-16
+]
+TIME_INPUT_FORMATS = [
+    "%H:%M:%S",  # 14:30:59
+    "%H:%M",  # 14:30
+]
+DATETIME_INPUT_FORMATS = [
+    "%d/%m/%Y %H:%M:%S",  # 25/10/2006 14:30:59
+    "%d/%m/%Y %H:%M",  # 25/10/2006 14:30
+]
+DECIMAL_SEPARATOR = "."
+THOUSAND_SEPARATOR = ","
+# NUMBER_GROUPING =

env/lib/python3.8/site-packages/django/conf/locale/bs/formats.py

@@ -0,0 +1,21 @@
+# This file is distributed under the same license as the Django package.
+#
+# The *_FORMAT strings use the Django date format syntax,
+# see https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date
+DATE_FORMAT = "j. N Y."
+TIME_FORMAT = "G:i"
+DATETIME_FORMAT = "j. N. Y. G:i T"
+YEAR_MONTH_FORMAT = "F Y."
+MONTH_DAY_FORMAT = "j. F"
+SHORT_DATE_FORMAT = "Y M j"
+# SHORT_DATETIME_FORMAT =
+# FIRST_DAY_OF_WEEK =
+
+# The *_INPUT_FORMATS strings use the Python strftime format syntax,
+# see https://docs.python.org/library/datetime.html#strftime-strptime-behavior
+# DATE_INPUT_FORMATS =
+# TIME_INPUT_FORMATS =
+# DATETIME_INPUT_FORMATS =
+DECIMAL_SEPARATOR = ","
+THOUSAND_SEPARATOR = "."
+# NUMBER_GROUPING =

env/lib/python3.8/site-packages/django/conf/locale/ca/formats.py

@@ -0,0 +1,30 @@
+# This file is distributed under the same license as the Django package.
+#
+# The *_FORMAT strings use the Django date format syntax,
+# see https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date
+DATE_FORMAT = r"j E \d\e Y"
+TIME_FORMAT = "G:i"
+DATETIME_FORMAT = r"j E \d\e Y \a \l\e\s G:i"
+YEAR_MONTH_FORMAT = r"F \d\e\l Y"
+MONTH_DAY_FORMAT = r"j E"
+SHORT_DATE_FORMAT = "d/m/Y"
+SHORT_DATETIME_FORMAT = "d/m/Y G:i"
+FIRST_DAY_OF_WEEK = 1  # Monday
+
+# The *_INPUT_FORMATS strings use the Python strftime format syntax,
+# see https://docs.python.org/library/datetime.html#strftime-strptime-behavior
+DATE_INPUT_FORMATS = [
+    "%d/%m/%Y",  # '31/12/2009'
+    "%d/%m/%y",  # '31/12/09'
+]
+DATETIME_INPUT_FORMATS = [
+    "%d/%m/%Y %H:%M:%S",
+    "%d/%m/%Y %H:%M:%S.%f",
+    "%d/%m/%Y %H:%M",
+    "%d/%m/%y %H:%M:%S",
+    "%d/%m/%y %H:%M:%S.%f",
+    "%d/%m/%y %H:%M",
+]
+DECIMAL_SEPARATOR = ","
+THOUSAND_SEPARATOR = "."
+NUMBER_GROUPING = 3

env/lib/python3.8/site-packages/django/conf/locale/cs/formats.py

@@ -0,0 +1,43 @@
+# This file is distributed under the same license as the Django package.
+#
+# The *_FORMAT strings use the Django date format syntax,
+# see https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date
+DATE_FORMAT = "j. E Y"
+TIME_FORMAT = "G:i"
+DATETIME_FORMAT = "j. E Y G:i"
+YEAR_MONTH_FORMAT = "F Y"
+MONTH_DAY_FORMAT = "j. F"
+SHORT_DATE_FORMAT = "d.m.Y"
+SHORT_DATETIME_FORMAT = "d.m.Y G:i"
+FIRST_DAY_OF_WEEK = 1  # Monday
+
+# The *_INPUT_FORMATS strings use the Python strftime format syntax,
+# see https://docs.python.org/library/datetime.html#strftime-strptime-behavior
+DATE_INPUT_FORMATS = [
+    "%d.%m.%Y",  # '05.01.2006'
+    "%d.%m.%y",  # '05.01.06'
+    "%d. %m. %Y",  # '5. 1. 2006'
+    "%d. %m. %y",  # '5. 1. 06'
+    # "%d. %B %Y",  # '25. October 2006'
+    # "%d. %b. %Y",  # '25. Oct. 2006'
+]
+# Kept ISO formats as one is in first position
+TIME_INPUT_FORMATS = [
+    "%H:%M:%S",  # '04:30:59'
+    "%H.%M",  # '04.30'
+    "%H:%M",  # '04:30'
+]
+DATETIME_INPUT_FORMATS = [
+    "%d.%m.%Y %H:%M:%S",  # '05.01.2006 04:30:59'
+    "%d.%m.%Y %H:%M:%S.%f",  # '05.01.2006 04:30:59.000200'
+    "%d.%m.%Y %H.%M",  # '05.01.2006 04.30'
+    "%d.%m.%Y %H:%M",  # '05.01.2006 04:30'
+    "%d. %m. %Y %H:%M:%S",  # '05. 01. 2006 04:30:59'
+    "%d. %m. %Y %H:%M:%S.%f",  # '05. 01. 2006 04:30:59.000200'
+    "%d. %m. %Y %H.%M",  # '05. 01. 2006 04.30'
+    "%d. %m. %Y %H:%M",  # '05. 01. 2006 04:30'
+    "%Y-%m-%d %H.%M",  # '2006-01-05 04.30'
+]
+DECIMAL_SEPARATOR = ","
+THOUSAND_SEPARATOR = "\xa0"  # non-breaking space
+NUMBER_GROUPING = 3

env/lib/python3.8/site-packages/django/conf/locale/cy/formats.py

@@ -0,0 +1,33 @@
+# This file is distributed under the same license as the Django package.
+#
+# The *_FORMAT strings use the Django date format syntax,
+# see https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date
+DATE_FORMAT = "j F Y"  # '25 Hydref 2006'
+TIME_FORMAT = "P"  # '2:30 y.b.'
+DATETIME_FORMAT = "j F Y, P"  # '25 Hydref 2006, 2:30 y.b.'
+YEAR_MONTH_FORMAT = "F Y"  # 'Hydref 2006'
+MONTH_DAY_FORMAT = "j F"  # '25 Hydref'
+SHORT_DATE_FORMAT = "d/m/Y"  # '25/10/2006'
+SHORT_DATETIME_FORMAT = "d/m/Y P"  # '25/10/2006 2:30 y.b.'
+FIRST_DAY_OF_WEEK = 1  # 'Dydd Llun'
+
+# The *_INPUT_FORMATS strings use the Python strftime format syntax,
+# see https://docs.python.org/library/datetime.html#strftime-strptime-behavior
+DATE_INPUT_FORMATS = [
+    "%d/%m/%Y",  # '25/10/2006'
+    "%d/%m/%y",  # '25/10/06'
+]
+DATETIME_INPUT_FORMATS = [
+    "%Y-%m-%d %H:%M:%S",  # '2006-10-25 14:30:59'
+    "%Y-%m-%d %H:%M:%S.%f",  # '2006-10-25 14:30:59.000200'
+    "%Y-%m-%d %H:%M",  # '2006-10-25 14:30'
+    "%d/%m/%Y %H:%M:%S",  # '25/10/2006 14:30:59'
+    "%d/%m/%Y %H:%M:%S.%f",  # '25/10/2006 14:30:59.000200'
+    "%d/%m/%Y %H:%M",  # '25/10/2006 14:30'
+    "%d/%m/%y %H:%M:%S",  # '25/10/06 14:30:59'
+    "%d/%m/%y %H:%M:%S.%f",  # '25/10/06 14:30:59.000200'
+    "%d/%m/%y %H:%M",  # '25/10/06 14:30'
+]
+DECIMAL_SEPARATOR = "."
+THOUSAND_SEPARATOR = ","
+NUMBER_GROUPING = 3

env/lib/python3.8/site-packages/django/conf/locale/da/formats.py

@@ -0,0 +1,26 @@
+# This file is distributed under the same license as the Django package.
+#
+# The *_FORMAT strings use the Django date format syntax,
+# see https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date
+DATE_FORMAT = "j. F Y"
+TIME_FORMAT = "H:i"
+DATETIME_FORMAT = "j. F Y H:i"
+YEAR_MONTH_FORMAT = "F Y"
+MONTH_DAY_FORMAT = "j. F"
+SHORT_DATE_FORMAT = "d.m.Y"
+SHORT_DATETIME_FORMAT = "d.m.Y H:i"
+FIRST_DAY_OF_WEEK = 1
+
+# The *_INPUT_FORMATS strings use the Python strftime format syntax,
+# see https://docs.python.org/library/datetime.html#strftime-strptime-behavior
+DATE_INPUT_FORMATS = [
+    "%d.%m.%Y",  # '25.10.2006'
+]
+DATETIME_INPUT_FORMATS = [
+    "%d.%m.%Y %H:%M:%S",  # '25.10.2006 14:30:59'
+    "%d.%m.%Y %H:%M:%S.%f",  # '25.10.2006 14:30:59.000200'
+    "%d.%m.%Y %H:%M",  # '25.10.2006 14:30'
+]
+DECIMAL_SEPARATOR = ","
+THOUSAND_SEPARATOR = "."
+NUMBER_GROUPING = 3

env/lib/python3.8/site-packages/django/conf/locale/de/formats.py

@@ -0,0 +1,29 @@
+# This file is distributed under the same license as the Django package.
+#
+# The *_FORMAT strings use the Django date format syntax,
+# see https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date
+DATE_FORMAT = "j. F Y"
+TIME_FORMAT = "H:i"
+DATETIME_FORMAT = "j. F Y H:i"
+YEAR_MONTH_FORMAT = "F Y"
+MONTH_DAY_FORMAT = "j. F"
+SHORT_DATE_FORMAT = "d.m.Y"
+SHORT_DATETIME_FORMAT = "d.m.Y H:i"
+FIRST_DAY_OF_WEEK = 1  # Monday
+
+# The *_INPUT_FORMATS strings use the Python strftime format syntax,
+# see https://docs.python.org/library/datetime.html#strftime-strptime-behavior
+DATE_INPUT_FORMATS = [
+    "%d.%m.%Y",  # '25.10.2006'
+    "%d.%m.%y",  # '25.10.06'
+    # "%d. %B %Y",  # '25. October 2006'
+    # "%d. %b. %Y",  # '25. Oct. 2006'
+]
+DATETIME_INPUT_FORMATS = [
+    "%d.%m.%Y %H:%M:%S",  # '25.10.2006 14:30:59'
+    "%d.%m.%Y %H:%M:%S.%f",  # '25.10.2006 14:30:59.000200'
+    "%d.%m.%Y %H:%M",  # '25.10.2006 14:30'
+]
+DECIMAL_SEPARATOR = ","
+THOUSAND_SEPARATOR = "."
+NUMBER_GROUPING = 3