änderung1

venv/lib/python3.7/site-packages/django/utils/archive.py

@@ -0,0 +1,227 @@
+"""
+Based on "python-archive" -- https://pypi.org/project/python-archive/
+
+Copyright (c) 2010 Gary Wilson Jr. <gary.wilson@gmail.com> and contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+"""
+import os
+import shutil
+import stat
+import tarfile
+import zipfile
+
+
+class ArchiveException(Exception):
+    """
+    Base exception class for all archive errors.
+    """
+
+
+class UnrecognizedArchiveFormat(ArchiveException):
+    """
+    Error raised when passed file is not a recognized archive format.
+    """
+
+
+def extract(path, to_path=''):
+    """
+    Unpack the tar or zip file at the specified path to the directory
+    specified by to_path.
+    """
+    with Archive(path) as archive:
+        archive.extract(to_path)
+
+
+class Archive:
+    """
+    The external API class that encapsulates an archive implementation.
+    """
+    def __init__(self, file):
+        self._archive = self._archive_cls(file)(file)
+
+    @staticmethod
+    def _archive_cls(file):
+        cls = None
+        if isinstance(file, str):
+            filename = file
+        else:
+            try:
+                filename = file.name
+            except AttributeError:
+                raise UnrecognizedArchiveFormat(
+                    "File object not a recognized archive format.")
+        base, tail_ext = os.path.splitext(filename.lower())
+        cls = extension_map.get(tail_ext)
+        if not cls:
+            base, ext = os.path.splitext(base)
+            cls = extension_map.get(ext)
+        if not cls:
+            raise UnrecognizedArchiveFormat(
+                "Path not a recognized archive format: %s" % filename)
+        return cls
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.close()
+
+    def extract(self, to_path=''):
+        self._archive.extract(to_path)
+
+    def list(self):
+        self._archive.list()
+
+    def close(self):
+        self._archive.close()
+
+
+class BaseArchive:
+    """
+    Base Archive class.  Implementations should inherit this class.
+    """
+    @staticmethod
+    def _copy_permissions(mode, filename):
+        """
+        If the file in the archive has some permissions (this assumes a file
+        won't be writable/executable without being readable), apply those
+        permissions to the unarchived file.
+        """
+        if mode & stat.S_IROTH:
+            os.chmod(filename, mode)
+
+    def split_leading_dir(self, path):
+        path = str(path)
+        path = path.lstrip('/').lstrip('\\')
+        if '/' in path and (('\\' in path and path.find('/') < path.find('\\')) or '\\' not in path):
+            return path.split('/', 1)
+        elif '\\' in path:
+            return path.split('\\', 1)
+        else:
+            return path, ''
+
+    def has_leading_dir(self, paths):
+        """
+        Return True if all the paths have the same leading path name
+        (i.e., everything is in one subdirectory in an archive).
+        """
+        common_prefix = None
+        for path in paths:
+            prefix, rest = self.split_leading_dir(path)
+            if not prefix:
+                return False
+            elif common_prefix is None:
+                common_prefix = prefix
+            elif prefix != common_prefix:
+                return False
+        return True
+
+    def extract(self):
+        raise NotImplementedError('subclasses of BaseArchive must provide an extract() method')
+
+    def list(self):
+        raise NotImplementedError('subclasses of BaseArchive must provide a list() method')
+
+
+class TarArchive(BaseArchive):
+
+    def __init__(self, file):
+        self._archive = tarfile.open(file)
+
+    def list(self, *args, **kwargs):
+        self._archive.list(*args, **kwargs)
+
+    def extract(self, to_path):
+        members = self._archive.getmembers()
+        leading = self.has_leading_dir(x.name for x in members)
+        for member in members:
+            name = member.name
+            if leading:
+                name = self.split_leading_dir(name)[1]
+            filename = os.path.join(to_path, name)
+            if member.isdir():
+                if filename and not os.path.exists(filename):
+                    os.makedirs(filename)
+            else:
+                try:
+                    extracted = self._archive.extractfile(member)
+                except (KeyError, AttributeError) as exc:
+                    # Some corrupt tar files seem to produce this
+                    # (specifically bad symlinks)
+                    print("In the tar file %s the member %s is invalid: %s" %
+                          (name, member.name, exc))
+                else:
+                    dirname = os.path.dirname(filename)
+                    if dirname and not os.path.exists(dirname):
+                        os.makedirs(dirname)
+                    with open(filename, 'wb') as outfile:
+                        shutil.copyfileobj(extracted, outfile)
+                        self._copy_permissions(member.mode, filename)
+                finally:
+                    if extracted:
+                        extracted.close()
+
+    def close(self):
+        self._archive.close()
+
+
+class ZipArchive(BaseArchive):
+
+    def __init__(self, file):
+        self._archive = zipfile.ZipFile(file)
+
+    def list(self, *args, **kwargs):
+        self._archive.printdir(*args, **kwargs)
+
+    def extract(self, to_path):
+        namelist = self._archive.namelist()
+        leading = self.has_leading_dir(namelist)
+        for name in namelist:
+            data = self._archive.read(name)
+            info = self._archive.getinfo(name)
+            if leading:
+                name = self.split_leading_dir(name)[1]
+            filename = os.path.join(to_path, name)
+            dirname = os.path.dirname(filename)
+            if dirname and not os.path.exists(dirname):
+                os.makedirs(dirname)
+            if filename.endswith(('/', '\\')):
+                # A directory
+                if not os.path.exists(filename):
+                    os.makedirs(filename)
+            else:
+                with open(filename, 'wb') as outfile:
+                    outfile.write(data)
+                # Convert ZipInfo.external_attr to mode
+                mode = info.external_attr >> 16
+                self._copy_permissions(mode, filename)
+
+    def close(self):
+        self._archive.close()
+
+
+extension_map = {
+    '.tar': TarArchive,
+    '.tar.bz2': TarArchive,
+    '.tar.gz': TarArchive,
+    '.tgz': TarArchive,
+    '.tz2': TarArchive,
+    '.zip': ZipArchive,
+}

venv/lib/python3.7/site-packages/django/utils/baseconv.py

@@ -0,0 +1,101 @@
+# Copyright (c) 2010 Guilherme Gondim. All rights reserved.
+# Copyright (c) 2009 Simon Willison. All rights reserved.
+# Copyright (c) 2002 Drew Perttula. All rights reserved.
+#
+# License:
+#   Python Software Foundation License version 2
+#
+# See the file "LICENSE" for terms & conditions for usage, and a DISCLAIMER OF
+# ALL WARRANTIES.
+#
+# This Baseconv distribution contains no GNU General Public Licensed (GPLed)
+# code so it may be used in proprietary projects just like prior ``baseconv``
+# distributions.
+#
+# All trademarks referenced herein are property of their respective holders.
+#
+
+"""
+Convert numbers from base 10 integers to base X strings and back again.
+
+Sample usage::
+
+  >>> base20 = BaseConverter('0123456789abcdefghij')
+  >>> base20.encode(1234)
+  '31e'
+  >>> base20.decode('31e')
+  1234
+  >>> base20.encode(-1234)
+  '-31e'
+  >>> base20.decode('-31e')
+  -1234
+  >>> base11 = BaseConverter('0123456789-', sign='$')
+  >>> base11.encode('$1234')
+  '$-22'
+  >>> base11.decode('$-22')
+  '$1234'
+
+"""
+
+BASE2_ALPHABET = '01'
+BASE16_ALPHABET = '0123456789ABCDEF'
+BASE56_ALPHABET = '23456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnpqrstuvwxyz'
+BASE36_ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz'
+BASE62_ALPHABET = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
+BASE64_ALPHABET = BASE62_ALPHABET + '-_'
+
+
+class BaseConverter:
+    decimal_digits = '0123456789'
+
+    def __init__(self, digits, sign='-'):
+        self.sign = sign
+        self.digits = digits
+        if sign in self.digits:
+            raise ValueError('Sign character found in converter base digits.')
+
+    def __repr__(self):
+        return "<%s: base%s (%s)>" % (self.__class__.__name__, len(self.digits), self.digits)
+
+    def encode(self, i):
+        neg, value = self.convert(i, self.decimal_digits, self.digits, '-')
+        if neg:
+            return self.sign + value
+        return value
+
+    def decode(self, s):
+        neg, value = self.convert(s, self.digits, self.decimal_digits, self.sign)
+        if neg:
+            value = '-' + value
+        return int(value)
+
+    def convert(self, number, from_digits, to_digits, sign):
+        if str(number)[0] == sign:
+            number = str(number)[1:]
+            neg = 1
+        else:
+            neg = 0
+
+        # make an integer out of the number
+        x = 0
+        for digit in str(number):
+            x = x * len(from_digits) + from_digits.index(digit)
+
+        # create the result in base 'len(to_digits)'
+        if x == 0:
+            res = to_digits[0]
+        else:
+            res = ''
+            while x > 0:
+                digit = x % len(to_digits)
+                res = to_digits[digit] + res
+                x = int(x // len(to_digits))
+        return neg, res
+
+
+base2 = BaseConverter(BASE2_ALPHABET)
+base16 = BaseConverter(BASE16_ALPHABET)
+base36 = BaseConverter(BASE36_ALPHABET)
+base56 = BaseConverter(BASE56_ALPHABET)
+base62 = BaseConverter(BASE62_ALPHABET)
+base64 = BaseConverter(BASE64_ALPHABET, sign='$')

venv/lib/python3.7/site-packages/django/utils/dateparse.py

@@ -0,0 +1,146 @@
+"""Functions to parse datetime objects."""
+
+# We're using regular expressions rather than time.strptime because:
+# - They provide both validation and parsing.
+# - They're more flexible for datetimes.
+# - The date/datetime/time constructors produce friendlier error messages.
+
+import datetime
+import re
+
+from django.utils.timezone import get_fixed_timezone, utc
+
+date_re = re.compile(
+    r'(?P<year>\d{4})-(?P<month>\d{1,2})-(?P<day>\d{1,2})$'
+)
+
+time_re = re.compile(
+    r'(?P<hour>\d{1,2}):(?P<minute>\d{1,2})'
+    r'(?::(?P<second>\d{1,2})(?:\.(?P<microsecond>\d{1,6})\d{0,6})?)?'
+)
+
+datetime_re = re.compile(
+    r'(?P<year>\d{4})-(?P<month>\d{1,2})-(?P<day>\d{1,2})'
+    r'[T ](?P<hour>\d{1,2}):(?P<minute>\d{1,2})'
+    r'(?::(?P<second>\d{1,2})(?:\.(?P<microsecond>\d{1,6})\d{0,6})?)?'
+    r'(?P<tzinfo>Z|[+-]\d{2}(?::?\d{2})?)?$'
+)
+
+standard_duration_re = re.compile(
+    r'^'
+    r'(?:(?P<days>-?\d+) (days?, )?)?'
+    r'((?:(?P<hours>-?\d+):)(?=\d+:\d+))?'
+    r'(?:(?P<minutes>-?\d+):)?'
+    r'(?P<seconds>-?\d+)'
+    r'(?:\.(?P<microseconds>\d{1,6})\d{0,6})?'
+    r'$'
+)
+
+# Support the sections of ISO 8601 date representation that are accepted by
+# timedelta
+iso8601_duration_re = re.compile(
+    r'^(?P<sign>[-+]?)'
+    r'P'
+    r'(?:(?P<days>\d+(.\d+)?)D)?'
+    r'(?:T'
+    r'(?:(?P<hours>\d+(.\d+)?)H)?'
+    r'(?:(?P<minutes>\d+(.\d+)?)M)?'
+    r'(?:(?P<seconds>\d+(.\d+)?)S)?'
+    r')?'
+    r'$'
+)
+
+# Support PostgreSQL's day-time interval format, e.g. "3 days 04:05:06". The
+# year-month and mixed intervals cannot be converted to a timedelta and thus
+# aren't accepted.
+postgres_interval_re = re.compile(
+    r'^'
+    r'(?:(?P<days>-?\d+) (days? ?))?'
+    r'(?:(?P<sign>[-+])?'
+    r'(?P<hours>\d+):'
+    r'(?P<minutes>\d\d):'
+    r'(?P<seconds>\d\d)'
+    r'(?:\.(?P<microseconds>\d{1,6}))?'
+    r')?$'
+)
+
+
+def parse_date(value):
+    """Parse a string and return a datetime.date.
+
+    Raise ValueError if the input is well formatted but not a valid date.
+    Return None if the input isn't well formatted.
+    """
+    match = date_re.match(value)
+    if match:
+        kw = {k: int(v) for k, v in match.groupdict().items()}
+        return datetime.date(**kw)
+
+
+def parse_time(value):
+    """Parse a string and return a datetime.time.
+
+    This function doesn't support time zone offsets.
+
+    Raise ValueError if the input is well formatted but not a valid time.
+    Return None if the input isn't well formatted, in particular if it
+    contains an offset.
+    """
+    match = time_re.match(value)
+    if match:
+        kw = match.groupdict()
+        kw['microsecond'] = kw['microsecond'] and kw['microsecond'].ljust(6, '0')
+        kw = {k: int(v) for k, v in kw.items() if v is not None}
+        return datetime.time(**kw)
+
+
+def parse_datetime(value):
+    """Parse a string and return a datetime.datetime.
+
+    This function supports time zone offsets. When the input contains one,
+    the output uses a timezone with a fixed offset from UTC.
+
+    Raise ValueError if the input is well formatted but not a valid datetime.
+    Return None if the input isn't well formatted.
+    """
+    match = datetime_re.match(value)
+    if match:
+        kw = match.groupdict()
+        kw['microsecond'] = kw['microsecond'] and kw['microsecond'].ljust(6, '0')
+        tzinfo = kw.pop('tzinfo')
+        if tzinfo == 'Z':
+            tzinfo = utc
+        elif tzinfo is not None:
+            offset_mins = int(tzinfo[-2:]) if len(tzinfo) > 3 else 0
+            offset = 60 * int(tzinfo[1:3]) + offset_mins
+            if tzinfo[0] == '-':
+                offset = -offset
+            tzinfo = get_fixed_timezone(offset)
+        kw = {k: int(v) for k, v in kw.items() if v is not None}
+        kw['tzinfo'] = tzinfo
+        return datetime.datetime(**kw)
+
+
+def parse_duration(value):
+    """Parse a duration string and return a datetime.timedelta.
+
+    The preferred format for durations in Django is '%d %H:%M:%S.%f'.
+
+    Also supports ISO 8601 representation and PostgreSQL's day-time interval
+    format.
+    """
+    match = (
+        standard_duration_re.match(value) or
+        iso8601_duration_re.match(value) or
+        postgres_interval_re.match(value)
+    )
+    if match:
+        kw = match.groupdict()
+        days = datetime.timedelta(float(kw.pop('days', 0) or 0))
+        sign = -1 if kw.pop('sign', '+') == '-' else 1
+        if kw.get('microseconds'):
+            kw['microseconds'] = kw['microseconds'].ljust(6, '0')
+        if kw.get('seconds') and kw.get('microseconds') and kw['seconds'].startswith('-'):
+            kw['microseconds'] = '-' + kw['microseconds']
+        kw = {k: float(v) for k, v in kw.items() if v is not None}
+        return days + sign * datetime.timedelta(**kw)

venv/lib/python3.7/site-packages/django/utils/dates.py

@@ -0,0 +1,49 @@
+"Commonly-used date structures"
+
+from django.utils.translation import gettext_lazy as _, pgettext_lazy
+
+WEEKDAYS = {
+    0: _('Monday'), 1: _('Tuesday'), 2: _('Wednesday'), 3: _('Thursday'), 4: _('Friday'),
+    5: _('Saturday'), 6: _('Sunday')
+}
+WEEKDAYS_ABBR = {
+    0: _('Mon'), 1: _('Tue'), 2: _('Wed'), 3: _('Thu'), 4: _('Fri'),
+    5: _('Sat'), 6: _('Sun')
+}
+MONTHS = {
+    1: _('January'), 2: _('February'), 3: _('March'), 4: _('April'), 5: _('May'), 6: _('June'),
+    7: _('July'), 8: _('August'), 9: _('September'), 10: _('October'), 11: _('November'),
+    12: _('December')
+}
+MONTHS_3 = {
+    1: _('jan'), 2: _('feb'), 3: _('mar'), 4: _('apr'), 5: _('may'), 6: _('jun'),
+    7: _('jul'), 8: _('aug'), 9: _('sep'), 10: _('oct'), 11: _('nov'), 12: _('dec')
+}
+MONTHS_AP = {  # month names in Associated Press style
+    1: pgettext_lazy('abbrev. month', 'Jan.'),
+    2: pgettext_lazy('abbrev. month', 'Feb.'),
+    3: pgettext_lazy('abbrev. month', 'March'),
+    4: pgettext_lazy('abbrev. month', 'April'),
+    5: pgettext_lazy('abbrev. month', 'May'),
+    6: pgettext_lazy('abbrev. month', 'June'),
+    7: pgettext_lazy('abbrev. month', 'July'),
+    8: pgettext_lazy('abbrev. month', 'Aug.'),
+    9: pgettext_lazy('abbrev. month', 'Sept.'),
+    10: pgettext_lazy('abbrev. month', 'Oct.'),
+    11: pgettext_lazy('abbrev. month', 'Nov.'),
+    12: pgettext_lazy('abbrev. month', 'Dec.')
+}
+MONTHS_ALT = {  # required for long date representation by some locales
+    1: pgettext_lazy('alt. month', 'January'),
+    2: pgettext_lazy('alt. month', 'February'),
+    3: pgettext_lazy('alt. month', 'March'),
+    4: pgettext_lazy('alt. month', 'April'),
+    5: pgettext_lazy('alt. month', 'May'),
+    6: pgettext_lazy('alt. month', 'June'),
+    7: pgettext_lazy('alt. month', 'July'),
+    8: pgettext_lazy('alt. month', 'August'),
+    9: pgettext_lazy('alt. month', 'September'),
+    10: pgettext_lazy('alt. month', 'October'),
+    11: pgettext_lazy('alt. month', 'November'),
+    12: pgettext_lazy('alt. month', 'December')
+}

venv/lib/python3.7/site-packages/django/utils/deconstruct.py

@@ -0,0 +1,55 @@
+from importlib import import_module
+
+from django.utils.version import get_docs_version
+
+
+def deconstructible(*args, path=None):
+    """
+    Class decorator that allows the decorated class to be serialized
+    by the migrations subsystem.
+
+    The `path` kwarg specifies the import path.
+    """
+    def decorator(klass):
+        def __new__(cls, *args, **kwargs):
+            # We capture the arguments to make returning them trivial
+            obj = super(klass, cls).__new__(cls)
+            obj._constructor_args = (args, kwargs)
+            return obj
+
+        def deconstruct(obj):
+            """
+            Return a 3-tuple of class import path, positional arguments,
+            and keyword arguments.
+            """
+            # Fallback version
+            if path:
+                module_name, _, name = path.rpartition('.')
+            else:
+                module_name = obj.__module__
+                name = obj.__class__.__name__
+            # Make sure it's actually there and not an inner class
+            module = import_module(module_name)
+            if not hasattr(module, name):
+                raise ValueError(
+                    "Could not find object %s in %s.\n"
+                    "Please note that you cannot serialize things like inner "
+                    "classes. Please move the object into the main module "
+                    "body to use migrations.\n"
+                    "For more information, see "
+                    "https://docs.djangoproject.com/en/%s/topics/migrations/#serializing-values"
+                    % (name, module_name, get_docs_version()))
+            return (
+                path or '%s.%s' % (obj.__class__.__module__, name),
+                obj._constructor_args[0],
+                obj._constructor_args[1],
+            )
+
+        klass.__new__ = staticmethod(__new__)
+        klass.deconstruct = deconstruct
+
+        return klass
+
+    if not args:
+        return decorator
+    return decorator(*args)

venv/lib/python3.7/site-packages/django/utils/deprecation.py

@@ -0,0 +1,97 @@
+import inspect
+import warnings
+
+
+class RemovedInDjango30Warning(DeprecationWarning):
+    pass
+
+
+class RemovedInDjango31Warning(PendingDeprecationWarning):
+    pass
+
+
+RemovedInNextVersionWarning = RemovedInDjango30Warning
+
+
+class warn_about_renamed_method:
+    def __init__(self, class_name, old_method_name, new_method_name, deprecation_warning):
+        self.class_name = class_name
+        self.old_method_name = old_method_name
+        self.new_method_name = new_method_name
+        self.deprecation_warning = deprecation_warning
+
+    def __call__(self, f):
+        def wrapped(*args, **kwargs):
+            warnings.warn(
+                "`%s.%s` is deprecated, use `%s` instead." %
+                (self.class_name, self.old_method_name, self.new_method_name),
+                self.deprecation_warning, 2)
+            return f(*args, **kwargs)
+        return wrapped
+
+
+class RenameMethodsBase(type):
+    """
+    Handles the deprecation paths when renaming a method.
+
+    It does the following:
+        1) Define the new method if missing and complain about it.
+        2) Define the old method if missing.
+        3) Complain whenever an old method is called.
+
+    See #15363 for more details.
+    """
+
+    renamed_methods = ()
+
+    def __new__(cls, name, bases, attrs):
+        new_class = super().__new__(cls, name, bases, attrs)
+
+        for base in inspect.getmro(new_class):
+            class_name = base.__name__
+            for renamed_method in cls.renamed_methods:
+                old_method_name = renamed_method[0]
+                old_method = base.__dict__.get(old_method_name)
+                new_method_name = renamed_method[1]
+                new_method = base.__dict__.get(new_method_name)
+                deprecation_warning = renamed_method[2]
+                wrapper = warn_about_renamed_method(class_name, *renamed_method)
+
+                # Define the new method if missing and complain about it
+                if not new_method and old_method:
+                    warnings.warn(
+                        "`%s.%s` method should be renamed `%s`." %
+                        (class_name, old_method_name, new_method_name),
+                        deprecation_warning, 2)
+                    setattr(base, new_method_name, old_method)
+                    setattr(base, old_method_name, wrapper(old_method))
+
+                # Define the old method as a wrapped call to the new method.
+                if not old_method and new_method:
+                    setattr(base, old_method_name, wrapper(new_method))
+
+        return new_class
+
+
+class DeprecationInstanceCheck(type):
+    def __instancecheck__(self, instance):
+        warnings.warn(
+            "`%s` is deprecated, use `%s` instead." % (self.__name__, self.alternative),
+            self.deprecation_warning, 2
+        )
+        return super().__instancecheck__(instance)
+
+
+class MiddlewareMixin:
+    def __init__(self, get_response=None):
+        self.get_response = get_response
+        super().__init__()
+
+    def __call__(self, request):
+        response = None
+        if hasattr(self, 'process_request'):
+            response = self.process_request(request)
+        response = response or self.get_response(request)
+        if hasattr(self, 'process_response'):
+            response = self.process_response(request, response)
+        return response

venv/lib/python3.7/site-packages/django/utils/encoding.py

@@ -0,0 +1,269 @@
+import codecs
+import datetime
+import locale
+from decimal import Decimal
+from urllib.parse import quote
+
+from django.utils import six
+from django.utils.functional import Promise
+
+
+class DjangoUnicodeDecodeError(UnicodeDecodeError):
+    def __init__(self, obj, *args):
+        self.obj = obj
+        super().__init__(*args)
+
+    def __str__(self):
+        return '%s. You passed in %r (%s)' % (super().__str__(), self.obj, type(self.obj))
+
+
+# For backwards compatibility. (originally in Django, then added to six 1.9)
+python_2_unicode_compatible = six.python_2_unicode_compatible
+
+
+def smart_text(s, encoding='utf-8', strings_only=False, errors='strict'):
+    """
+    Return a string representing 's'. Treat bytestrings using the 'encoding'
+    codec.
+
+    If strings_only is True, don't convert (some) non-string-like objects.
+    """
+    if isinstance(s, Promise):
+        # The input is the result of a gettext_lazy() call.
+        return s
+    return force_text(s, encoding, strings_only, errors)
+
+
+_PROTECTED_TYPES = (
+    type(None), int, float, Decimal, datetime.datetime, datetime.date, datetime.time,
+)
+
+
+def is_protected_type(obj):
+    """Determine if the object instance is of a protected type.
+
+    Objects of protected types are preserved as-is when passed to
+    force_text(strings_only=True).
+    """
+    return isinstance(obj, _PROTECTED_TYPES)
+
+
+def force_text(s, encoding='utf-8', strings_only=False, errors='strict'):
+    """
+    Similar to smart_text, except that lazy instances are resolved to
+    strings, rather than kept as lazy objects.
+
+    If strings_only is True, don't convert (some) non-string-like objects.
+    """
+    # Handle the common case first for performance reasons.
+    if issubclass(type(s), str):
+        return s
+    if strings_only and is_protected_type(s):
+        return s
+    try:
+        if isinstance(s, bytes):
+            s = str(s, encoding, errors)
+        else:
+            s = str(s)
+    except UnicodeDecodeError as e:
+        raise DjangoUnicodeDecodeError(s, *e.args)
+    return s
+
+
+def smart_bytes(s, encoding='utf-8', strings_only=False, errors='strict'):
+    """
+    Return a bytestring version of 's', encoded as specified in 'encoding'.
+
+    If strings_only is True, don't convert (some) non-string-like objects.
+    """
+    if isinstance(s, Promise):
+        # The input is the result of a gettext_lazy() call.
+        return s
+    return force_bytes(s, encoding, strings_only, errors)
+
+
+def force_bytes(s, encoding='utf-8', strings_only=False, errors='strict'):
+    """
+    Similar to smart_bytes, except that lazy instances are resolved to
+    strings, rather than kept as lazy objects.
+
+    If strings_only is True, don't convert (some) non-string-like objects.
+    """
+    # Handle the common case first for performance reasons.
+    if isinstance(s, bytes):
+        if encoding == 'utf-8':
+            return s
+        else:
+            return s.decode('utf-8', errors).encode(encoding, errors)
+    if strings_only and is_protected_type(s):
+        return s
+    if isinstance(s, memoryview):
+        return bytes(s)
+    return str(s).encode(encoding, errors)
+
+
+smart_str = smart_text
+force_str = force_text
+
+smart_str.__doc__ = """
+Apply smart_text in Python 3 and smart_bytes in Python 2.
+
+This is suitable for writing to sys.stdout (for instance).
+"""
+
+force_str.__doc__ = """
+Apply force_text in Python 3 and force_bytes in Python 2.
+"""
+
+
+def iri_to_uri(iri):
+    """
+    Convert an Internationalized Resource Identifier (IRI) portion to a URI
+    portion that is suitable for inclusion in a URL.
+
+    This is the algorithm from section 3.1 of RFC 3987, slightly simplified
+    since the input is assumed to be a string rather than an arbitrary byte
+    stream.
+
+    Take an IRI (string or UTF-8 bytes, e.g. '/I ♥ Django/' or
+    b'/I \xe2\x99\xa5 Django/') and return a string containing the encoded
+    result with ASCII chars only (e.g. '/I%20%E2%99%A5%20Django/').
+    """
+    # The list of safe characters here is constructed from the "reserved" and
+    # "unreserved" characters specified in sections 2.2 and 2.3 of RFC 3986:
+    #     reserved    = gen-delims / sub-delims
+    #     gen-delims  = ":" / "/" / "?" / "#" / "[" / "]" / "@"
+    #     sub-delims  = "!" / "$" / "&" / "'" / "(" / ")"
+    #                   / "*" / "+" / "," / ";" / "="
+    #     unreserved  = ALPHA / DIGIT / "-" / "." / "_" / "~"
+    # Of the unreserved characters, urllib.parse.quote() already considers all
+    # but the ~ safe.
+    # The % character is also added to the list of safe characters here, as the
+    # end of section 3.1 of RFC 3987 specifically mentions that % must not be
+    # converted.
+    if iri is None:
+        return iri
+    elif isinstance(iri, Promise):
+        iri = str(iri)
+    return quote(iri, safe="/#%[]=:;$&()+,!?*@'~")
+
+
+# List of byte values that uri_to_iri() decodes from percent encoding.
+# First, the unreserved characters from RFC 3986:
+_ascii_ranges = [[45, 46, 95, 126], range(65, 91), range(97, 123)]
+_hextobyte = {
+    (fmt % char).encode(): bytes((char,))
+    for ascii_range in _ascii_ranges
+    for char in ascii_range
+    for fmt in ['%02x', '%02X']
+}
+# And then everything above 128, because bytes ≥ 128 are part of multibyte
+# unicode characters.
+_hexdig = '0123456789ABCDEFabcdef'
+_hextobyte.update({
+    (a + b).encode(): bytes.fromhex(a + b)
+    for a in _hexdig[8:] for b in _hexdig
+})
+
+
+def uri_to_iri(uri):
+    """
+    Convert a Uniform Resource Identifier(URI) into an Internationalized
+    Resource Identifier(IRI).
+
+    This is the algorithm from section 3.2 of RFC 3987, excluding step 4.
+
+    Take an URI in ASCII bytes (e.g. '/I%20%E2%99%A5%20Django/') and return
+    a string containing the encoded result (e.g. '/I%20♥%20Django/').
+    """
+    if uri is None:
+        return uri
+    uri = force_bytes(uri)
+    # Fast selective unqote: First, split on '%' and then starting with the
+    # second block, decode the first 2 bytes if they represent a hex code to
+    # decode. The rest of the block is the part after '%AB', not containing
+    # any '%'. Add that to the output without further processing.
+    bits = uri.split(b'%')
+    if len(bits) == 1:
+        iri = uri
+    else:
+        parts = [bits[0]]
+        append = parts.append
+        hextobyte = _hextobyte
+        for item in bits[1:]:
+            hex = item[:2]
+            if hex in hextobyte:
+                append(hextobyte[item[:2]])
+                append(item[2:])
+            else:
+                append(b'%')
+                append(item)
+        iri = b''.join(parts)
+    return repercent_broken_unicode(iri).decode()
+
+
+def escape_uri_path(path):
+    """
+    Escape the unsafe characters from the path portion of a Uniform Resource
+    Identifier (URI).
+    """
+    # These are the "reserved" and "unreserved" characters specified in
+    # sections 2.2 and 2.3 of RFC 2396:
+    #   reserved    = ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" | "$" | ","
+    #   unreserved  = alphanum | mark
+    #   mark        = "-" | "_" | "." | "!" | "~" | "*" | "'" | "(" | ")"
+    # The list of safe characters here is constructed subtracting ";", "=",
+    # and "?" according to section 3.3 of RFC 2396.
+    # The reason for not subtracting and escaping "/" is that we are escaping
+    # the entire path, not a path segment.
+    return quote(path, safe="/:@&+$,-_.!~*'()")
+
+
+def repercent_broken_unicode(path):
+    """
+    As per section 3.2 of RFC 3987, step three of converting a URI into an IRI,
+    repercent-encode any octet produced that is not part of a strictly legal
+    UTF-8 octet sequence.
+    """
+    while True:
+        try:
+            path.decode()
+        except UnicodeDecodeError as e:
+            # CVE-2019-14235: A recursion shouldn't be used since the exception
+            # handling uses massive amounts of memory
+            repercent = quote(path[e.start:e.end], safe=b"/#%[]=:;$&()+,!?*@'~")
+            path = path[:e.start] + force_bytes(repercent) + path[e.end:]
+        else:
+            return path
+
+
+def filepath_to_uri(path):
+    """Convert a file system path to a URI portion that is suitable for
+    inclusion in a URL.
+
+    Encode certain chars that would normally be recognized as special chars
+    for URIs. Do not encode the ' character, as it is a valid character
+    within URIs. See the encodeURIComponent() JavaScript function for details.
+    """
+    if path is None:
+        return path
+    # I know about `os.sep` and `os.altsep` but I want to leave
+    # some flexibility for hardcoding separators.
+    return quote(path.replace("\\", "/"), safe="/~!*()'")
+
+
+def get_system_encoding():
+    """
+    The encoding of the default system locale. Fallback to 'ascii' if the
+    #encoding is unsupported by Python or could not be determined. See tickets
+    #10335 and #5846.
+    """
+    try:
+        encoding = locale.getdefaultlocale()[1] or 'ascii'
+        codecs.lookup(encoding)
+    except Exception:
+        encoding = 'ascii'
+    return encoding
+
+
+DEFAULT_LOCALE_ENCODING = get_system_encoding()

venv/lib/python3.7/site-packages/django/utils/functional.py

@@ -0,0 +1,433 @@
+import copy
+import itertools
+import operator
+from functools import total_ordering, wraps
+
+from django.utils.version import PY36, get_docs_version
+
+
+# You can't trivially replace this with `functools.partial` because this binds
+# to classes and returns bound instances, whereas functools.partial (on
+# CPython) is a type and its instances don't bind.
+def curry(_curried_func, *args, **kwargs):
+    def _curried(*moreargs, **morekwargs):
+        return _curried_func(*args, *moreargs, **{**kwargs, **morekwargs})
+    return _curried
+
+
+class cached_property:
+    """
+    Decorator that converts a method with a single self argument into a
+    property cached on the instance.
+
+    A cached property can be made out of an existing method:
+    (e.g. ``url = cached_property(get_absolute_url)``).
+    On Python < 3.6, the optional ``name`` argument must be provided, e.g.
+    ``url = cached_property(get_absolute_url, name='url')``.
+    """
+    name = None
+
+    @staticmethod
+    def func(instance):
+        raise TypeError(
+            'Cannot use cached_property instance without calling '
+            '__set_name__() on it.'
+        )
+
+    @staticmethod
+    def _is_mangled(name):
+        return name.startswith('__') and not name.endswith('__')
+
+    def __init__(self, func, name=None):
+        if PY36:
+            self.real_func = func
+        else:
+            func_name = func.__name__
+            name = name or func_name
+            if not (isinstance(name, str) and name.isidentifier()):
+                raise ValueError(
+                    "%r can't be used as the name of a cached_property." % name,
+                )
+            if self._is_mangled(name):
+                raise ValueError(
+                    'cached_property does not work with mangled methods on '
+                    'Python < 3.6 without the appropriate `name` argument. See '
+                    'https://docs.djangoproject.com/en/%s/ref/utils/'
+                    '#cached-property-mangled-name' % get_docs_version(),
+                )
+            self.name = name
+            self.func = func
+        self.__doc__ = getattr(func, '__doc__')
+
+    def __set_name__(self, owner, name):
+        if self.name is None:
+            self.name = name
+            self.func = self.real_func
+        elif name != self.name:
+            raise TypeError(
+                "Cannot assign the same cached_property to two different names "
+                "(%r and %r)." % (self.name, name)
+            )
+
+    def __get__(self, instance, cls=None):
+        """
+        Call the function and put the return value in instance.__dict__ so that
+        subsequent attribute access on the instance returns the cached value
+        instead of calling cached_property.__get__().
+        """
+        if instance is None:
+            return self
+        res = instance.__dict__[self.name] = self.func(instance)
+        return res
+
+
+class Promise:
+    """
+    Base class for the proxy class created in the closure of the lazy function.
+    It's used to recognize promises in code.
+    """
+    pass
+
+
+def lazy(func, *resultclasses):
+    """
+    Turn any callable into a lazy evaluated callable. result classes or types
+    is required -- at least one is needed so that the automatic forcing of
+    the lazy evaluation code is triggered. Results are not memoized; the
+    function is evaluated on every access.
+    """
+
+    @total_ordering
+    class __proxy__(Promise):
+        """
+        Encapsulate a function call and act as a proxy for methods that are
+        called on the result of that function. The function is not evaluated
+        until one of the methods on the result is called.
+        """
+        __prepared = False
+
+        def __init__(self, args, kw):
+            self.__args = args
+            self.__kw = kw
+            if not self.__prepared:
+                self.__prepare_class__()
+            self.__prepared = True
+
+        def __reduce__(self):
+            return (
+                _lazy_proxy_unpickle,
+                (func, self.__args, self.__kw) + resultclasses
+            )
+
+        def __repr__(self):
+            return repr(self.__cast())
+
+        @classmethod
+        def __prepare_class__(cls):
+            for resultclass in resultclasses:
+                for type_ in resultclass.mro():
+                    for method_name in type_.__dict__:
+                        # All __promise__ return the same wrapper method, they
+                        # look up the correct implementation when called.
+                        if hasattr(cls, method_name):
+                            continue
+                        meth = cls.__promise__(method_name)
+                        setattr(cls, method_name, meth)
+            cls._delegate_bytes = bytes in resultclasses
+            cls._delegate_text = str in resultclasses
+            assert not (cls._delegate_bytes and cls._delegate_text), (
+                "Cannot call lazy() with both bytes and text return types.")
+            if cls._delegate_text:
+                cls.__str__ = cls.__text_cast
+            elif cls._delegate_bytes:
+                cls.__bytes__ = cls.__bytes_cast
+
+        @classmethod
+        def __promise__(cls, method_name):
+            # Builds a wrapper around some magic method
+            def __wrapper__(self, *args, **kw):
+                # Automatically triggers the evaluation of a lazy value and
+                # applies the given magic method of the result type.
+                res = func(*self.__args, **self.__kw)
+                return getattr(res, method_name)(*args, **kw)
+            return __wrapper__
+
+        def __text_cast(self):
+            return func(*self.__args, **self.__kw)
+
+        def __bytes_cast(self):
+            return bytes(func(*self.__args, **self.__kw))
+
+        def __bytes_cast_encoded(self):
+            return func(*self.__args, **self.__kw).encode()
+
+        def __cast(self):
+            if self._delegate_bytes:
+                return self.__bytes_cast()
+            elif self._delegate_text:
+                return self.__text_cast()
+            else:
+                return func(*self.__args, **self.__kw)
+
+        def __str__(self):
+            # object defines __str__(), so __prepare_class__() won't overload
+            # a __str__() method from the proxied class.
+            return str(self.__cast())
+
+        def __eq__(self, other):
+            if isinstance(other, Promise):
+                other = other.__cast()
+            return self.__cast() == other
+
+        def __lt__(self, other):
+            if isinstance(other, Promise):
+                other = other.__cast()
+            return self.__cast() < other
+
+        def __hash__(self):
+            return hash(self.__cast())
+
+        def __mod__(self, rhs):
+            if self._delegate_text:
+                return str(self) % rhs
+            return self.__cast() % rhs
+
+        def __deepcopy__(self, memo):
+            # Instances of this class are effectively immutable. It's just a
+            # collection of functions. So we don't need to do anything
+            # complicated for copying.
+            memo[id(self)] = self
+            return self
+
+    @wraps(func)
+    def __wrapper__(*args, **kw):
+        # Creates the proxy object, instead of the actual value.
+        return __proxy__(args, kw)
+
+    return __wrapper__
+
+
+def _lazy_proxy_unpickle(func, args, kwargs, *resultclasses):
+    return lazy(func, *resultclasses)(*args, **kwargs)
+
+
+def lazystr(text):
+    """
+    Shortcut for the common case of a lazy callable that returns str.
+    """
+    return lazy(str, str)(text)
+
+
+def keep_lazy(*resultclasses):
+    """
+    A decorator that allows a function to be called with one or more lazy
+    arguments. If none of the args are lazy, the function is evaluated
+    immediately, otherwise a __proxy__ is returned that will evaluate the
+    function when needed.
+    """
+    if not resultclasses:
+        raise TypeError("You must pass at least one argument to keep_lazy().")
+
+    def decorator(func):
+        lazy_func = lazy(func, *resultclasses)
+
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            if any(isinstance(arg, Promise) for arg in itertools.chain(args, kwargs.values())):
+                return lazy_func(*args, **kwargs)
+            return func(*args, **kwargs)
+        return wrapper
+    return decorator
+
+
+def keep_lazy_text(func):
+    """
+    A decorator for functions that accept lazy arguments and return text.
+    """
+    return keep_lazy(str)(func)
+
+
+empty = object()
+
+
+def new_method_proxy(func):
+    def inner(self, *args):
+        if self._wrapped is empty:
+            self._setup()
+        return func(self._wrapped, *args)
+    return inner
+
+
+class LazyObject:
+    """
+    A wrapper for another class that can be used to delay instantiation of the
+    wrapped class.
+
+    By subclassing, you have the opportunity to intercept and alter the
+    instantiation. If you don't need to do that, use SimpleLazyObject.
+    """
+
+    # Avoid infinite recursion when tracing __init__ (#19456).
+    _wrapped = None
+
+    def __init__(self):
+        # Note: if a subclass overrides __init__(), it will likely need to
+        # override __copy__() and __deepcopy__() as well.
+        self._wrapped = empty
+
+    __getattr__ = new_method_proxy(getattr)
+
+    def __setattr__(self, name, value):
+        if name == "_wrapped":
+            # Assign to __dict__ to avoid infinite __setattr__ loops.
+            self.__dict__["_wrapped"] = value
+        else:
+            if self._wrapped is empty:
+                self._setup()
+            setattr(self._wrapped, name, value)
+
+    def __delattr__(self, name):
+        if name == "_wrapped":
+            raise TypeError("can't delete _wrapped.")
+        if self._wrapped is empty:
+            self._setup()
+        delattr(self._wrapped, name)
+
+    def _setup(self):
+        """
+        Must be implemented by subclasses to initialize the wrapped object.
+        """
+        raise NotImplementedError('subclasses of LazyObject must provide a _setup() method')
+
+    # Because we have messed with __class__ below, we confuse pickle as to what
+    # class we are pickling. We're going to have to initialize the wrapped
+    # object to successfully pickle it, so we might as well just pickle the
+    # wrapped object since they're supposed to act the same way.
+    #
+    # Unfortunately, if we try to simply act like the wrapped object, the ruse
+    # will break down when pickle gets our id(). Thus we end up with pickle
+    # thinking, in effect, that we are a distinct object from the wrapped
+    # object, but with the same __dict__. This can cause problems (see #25389).
+    #
+    # So instead, we define our own __reduce__ method and custom unpickler. We
+    # pickle the wrapped object as the unpickler's argument, so that pickle
+    # will pickle it normally, and then the unpickler simply returns its
+    # argument.
+    def __reduce__(self):
+        if self._wrapped is empty:
+            self._setup()
+        return (unpickle_lazyobject, (self._wrapped,))
+
+    def __copy__(self):
+        if self._wrapped is empty:
+            # If uninitialized, copy the wrapper. Use type(self), not
+            # self.__class__, because the latter is proxied.
+            return type(self)()
+        else:
+            # If initialized, return a copy of the wrapped object.
+            return copy.copy(self._wrapped)
+
+    def __deepcopy__(self, memo):
+        if self._wrapped is empty:
+            # We have to use type(self), not self.__class__, because the
+            # latter is proxied.
+            result = type(self)()
+            memo[id(self)] = result
+            return result
+        return copy.deepcopy(self._wrapped, memo)
+
+    __bytes__ = new_method_proxy(bytes)
+    __str__ = new_method_proxy(str)
+    __bool__ = new_method_proxy(bool)
+
+    # Introspection support
+    __dir__ = new_method_proxy(dir)
+
+    # Need to pretend to be the wrapped class, for the sake of objects that
+    # care about this (especially in equality tests)
+    __class__ = property(new_method_proxy(operator.attrgetter("__class__")))
+    __eq__ = new_method_proxy(operator.eq)
+    __lt__ = new_method_proxy(operator.lt)
+    __gt__ = new_method_proxy(operator.gt)
+    __ne__ = new_method_proxy(operator.ne)
+    __hash__ = new_method_proxy(hash)
+
+    # List/Tuple/Dictionary methods support
+    __getitem__ = new_method_proxy(operator.getitem)
+    __setitem__ = new_method_proxy(operator.setitem)
+    __delitem__ = new_method_proxy(operator.delitem)
+    __iter__ = new_method_proxy(iter)
+    __len__ = new_method_proxy(len)
+    __contains__ = new_method_proxy(operator.contains)
+
+
+def unpickle_lazyobject(wrapped):
+    """
+    Used to unpickle lazy objects. Just return its argument, which will be the
+    wrapped object.
+    """
+    return wrapped
+
+
+class SimpleLazyObject(LazyObject):
+    """
+    A lazy object initialized from any function.
+
+    Designed for compound objects of unknown type. For builtins or objects of
+    known type, use django.utils.functional.lazy.
+    """
+    def __init__(self, func):
+        """
+        Pass in a callable that returns the object to be wrapped.
+
+        If copies are made of the resulting SimpleLazyObject, which can happen
+        in various circumstances within Django, then you must ensure that the
+        callable can be safely run more than once and will return the same
+        value.
+        """
+        self.__dict__['_setupfunc'] = func
+        super().__init__()
+
+    def _setup(self):
+        self._wrapped = self._setupfunc()
+
+    # Return a meaningful representation of the lazy object for debugging
+    # without evaluating the wrapped object.
+    def __repr__(self):
+        if self._wrapped is empty:
+            repr_attr = self._setupfunc
+        else:
+            repr_attr = self._wrapped
+        return '<%s: %r>' % (type(self).__name__, repr_attr)
+
+    def __copy__(self):
+        if self._wrapped is empty:
+            # If uninitialized, copy the wrapper. Use SimpleLazyObject, not
+            # self.__class__, because the latter is proxied.
+            return SimpleLazyObject(self._setupfunc)
+        else:
+            # If initialized, return a copy of the wrapped object.
+            return copy.copy(self._wrapped)
+
+    def __deepcopy__(self, memo):
+        if self._wrapped is empty:
+            # We have to use SimpleLazyObject, not self.__class__, because the
+            # latter is proxied.
+            result = SimpleLazyObject(self._setupfunc)
+            memo[id(self)] = result
+            return result
+        return copy.deepcopy(self._wrapped, memo)
+
+
+def partition(predicate, values):
+    """
+    Split the values into two sets, based on the return value of the function
+    (True/False). e.g.:
+
+        >>> partition(lambda x: x > 3, range(5))
+        [0, 1, 2, 3], [4]
+    """
+    results = ([], [])
+    for item in values:
+        results[predicate(item)].append(item)
+    return results

venv/lib/python3.7/site-packages/django/utils/http.py

@@ -0,0 +1,458 @@
+import base64
+import calendar
+import datetime
+import re
+import unicodedata
+import warnings
+from binascii import Error as BinasciiError
+from email.utils import formatdate
+from urllib.parse import (
+    ParseResult, SplitResult, _coerce_args, _splitnetloc, _splitparams, quote,
+    quote_plus, scheme_chars, unquote, unquote_plus,
+    urlencode as original_urlencode, uses_params,
+)
+
+from django.core.exceptions import TooManyFieldsSent
+from django.utils.datastructures import MultiValueDict
+from django.utils.deprecation import RemovedInDjango30Warning
+from django.utils.functional import keep_lazy_text
+
+# based on RFC 7232, Appendix C
+ETAG_MATCH = re.compile(r'''
+    \A(      # start of string and capture group
+    (?:W/)?  # optional weak indicator
+    "        # opening quote
+    [^"]*    # any sequence of non-quote characters
+    "        # end quote
+    )\Z      # end of string and capture group
+''', re.X)
+
+MONTHS = 'jan feb mar apr may jun jul aug sep oct nov dec'.split()
+__D = r'(?P<day>\d{2})'
+__D2 = r'(?P<day>[ \d]\d)'
+__M = r'(?P<mon>\w{3})'
+__Y = r'(?P<year>\d{4})'
+__Y2 = r'(?P<year>\d{2})'
+__T = r'(?P<hour>\d{2}):(?P<min>\d{2}):(?P<sec>\d{2})'
+RFC1123_DATE = re.compile(r'^\w{3}, %s %s %s %s GMT$' % (__D, __M, __Y, __T))
+RFC850_DATE = re.compile(r'^\w{6,9}, %s-%s-%s %s GMT$' % (__D, __M, __Y2, __T))
+ASCTIME_DATE = re.compile(r'^\w{3} %s %s %s %s$' % (__M, __D2, __T, __Y))
+
+RFC3986_GENDELIMS = ":/?#[]@"
+RFC3986_SUBDELIMS = "!$&'()*+,;="
+
+FIELDS_MATCH = re.compile('[&;]')
+
+
+@keep_lazy_text
+def urlquote(url, safe='/'):
+    """
+    A legacy compatibility wrapper to Python's urllib.parse.quote() function.
+    (was used for unicode handling on Python 2)
+    """
+    return quote(url, safe)
+
+
+@keep_lazy_text
+def urlquote_plus(url, safe=''):
+    """
+    A legacy compatibility wrapper to Python's urllib.parse.quote_plus()
+    function. (was used for unicode handling on Python 2)
+    """
+    return quote_plus(url, safe)
+
+
+@keep_lazy_text
+def urlunquote(quoted_url):
+    """
+    A legacy compatibility wrapper to Python's urllib.parse.unquote() function.
+    (was used for unicode handling on Python 2)
+    """
+    return unquote(quoted_url)
+
+
+@keep_lazy_text
+def urlunquote_plus(quoted_url):
+    """
+    A legacy compatibility wrapper to Python's urllib.parse.unquote_plus()
+    function. (was used for unicode handling on Python 2)
+    """
+    return unquote_plus(quoted_url)
+
+
+def urlencode(query, doseq=False):
+    """
+    A version of Python's urllib.parse.urlencode() function that can operate on
+    MultiValueDict and non-string values.
+    """
+    if isinstance(query, MultiValueDict):
+        query = query.lists()
+    elif hasattr(query, 'items'):
+        query = query.items()
+    query_params = []
+    for key, value in query:
+        if value is None:
+            raise TypeError(
+                'Cannot encode None in a query string. Did you mean to pass '
+                'an empty string or omit the value?'
+            )
+        elif isinstance(value, (str, bytes)):
+            query_val = value
+        else:
+            try:
+                itr = iter(value)
+            except TypeError:
+                query_val = value
+            else:
+                # Consume generators and iterators, even when doseq=True, to
+                # work around https://bugs.python.org/issue31706.
+                query_val = []
+                for item in itr:
+                    if item is None:
+                        raise TypeError(
+                            'Cannot encode None in a query string. Did you '
+                            'mean to pass an empty string or omit the value?'
+                        )
+                    elif not isinstance(item, bytes):
+                        item = str(item)
+                    query_val.append(item)
+        query_params.append((key, query_val))
+    return original_urlencode(query_params, doseq)
+
+
+def cookie_date(epoch_seconds=None):
+    """
+    Format the time to ensure compatibility with Netscape's cookie standard.
+
+    `epoch_seconds` is a floating point number expressed in seconds since the
+    epoch, in UTC - such as that outputted by time.time(). If set to None, it
+    defaults to the current time.
+
+    Output a string in the format 'Wdy, DD-Mon-YYYY HH:MM:SS GMT'.
+    """
+    warnings.warn(
+        'cookie_date() is deprecated in favor of http_date(), which follows '
+        'the format of the latest RFC.',
+        RemovedInDjango30Warning, stacklevel=2,
+    )
+    rfcdate = formatdate(epoch_seconds)
+    return '%s-%s-%s GMT' % (rfcdate[:7], rfcdate[8:11], rfcdate[12:25])
+
+
+def http_date(epoch_seconds=None):
+    """
+    Format the time to match the RFC1123 date format as specified by HTTP
+    RFC7231 section 7.1.1.1.
+
+    `epoch_seconds` is a floating point number expressed in seconds since the
+    epoch, in UTC - such as that outputted by time.time(). If set to None, it
+    defaults to the current time.
+
+    Output a string in the format 'Wdy, DD Mon YYYY HH:MM:SS GMT'.
+    """
+    return formatdate(epoch_seconds, usegmt=True)
+
+
+def parse_http_date(date):
+    """
+    Parse a date format as specified by HTTP RFC7231 section 7.1.1.1.
+
+    The three formats allowed by the RFC are accepted, even if only the first
+    one is still in widespread use.
+
+    Return an integer expressed in seconds since the epoch, in UTC.
+    """
+    # email.utils.parsedate() does the job for RFC1123 dates; unfortunately
+    # RFC7231 makes it mandatory to support RFC850 dates too. So we roll
+    # our own RFC-compliant parsing.
+    for regex in RFC1123_DATE, RFC850_DATE, ASCTIME_DATE:
+        m = regex.match(date)
+        if m is not None:
+            break
+    else:
+        raise ValueError("%r is not in a valid HTTP date format" % date)
+    try:
+        year = int(m.group('year'))
+        if year < 100:
+            if year < 70:
+                year += 2000
+            else:
+                year += 1900
+        month = MONTHS.index(m.group('mon').lower()) + 1
+        day = int(m.group('day'))
+        hour = int(m.group('hour'))
+        min = int(m.group('min'))
+        sec = int(m.group('sec'))
+        result = datetime.datetime(year, month, day, hour, min, sec)
+        return calendar.timegm(result.utctimetuple())
+    except Exception as exc:
+        raise ValueError("%r is not a valid date" % date) from exc
+
+
+def parse_http_date_safe(date):
+    """
+    Same as parse_http_date, but return None if the input is invalid.
+    """
+    try:
+        return parse_http_date(date)
+    except Exception:
+        pass
+
+
+# Base 36 functions: useful for generating compact URLs
+
+def base36_to_int(s):
+    """
+    Convert a base 36 string to an int. Raise ValueError if the input won't fit
+    into an int.
+    """
+    # To prevent overconsumption of server resources, reject any
+    # base36 string that is longer than 13 base36 digits (13 digits
+    # is sufficient to base36-encode any 64-bit integer)
+    if len(s) > 13:
+        raise ValueError("Base36 input too large")
+    return int(s, 36)
+
+
+def int_to_base36(i):
+    """Convert an integer to a base36 string."""
+    char_set = '0123456789abcdefghijklmnopqrstuvwxyz'
+    if i < 0:
+        raise ValueError("Negative base36 conversion input.")
+    if i < 36:
+        return char_set[i]
+    b36 = ''
+    while i != 0:
+        i, n = divmod(i, 36)
+        b36 = char_set[n] + b36
+    return b36
+
+
+def urlsafe_base64_encode(s):
+    """
+    Encode a bytestring to a base64 string for use in URLs. Strip any trailing
+    equal signs.
+    """
+    return base64.urlsafe_b64encode(s).rstrip(b'\n=').decode('ascii')
+
+
+def urlsafe_base64_decode(s):
+    """
+    Decode a base64 encoded string. Add back any trailing equal signs that
+    might have been stripped.
+    """
+    s = s.encode()
+    try:
+        return base64.urlsafe_b64decode(s.ljust(len(s) + len(s) % 4, b'='))
+    except (LookupError, BinasciiError) as e:
+        raise ValueError(e)
+
+
+def parse_etags(etag_str):
+    """
+    Parse a string of ETags given in an If-None-Match or If-Match header as
+    defined by RFC 7232. Return a list of quoted ETags, or ['*'] if all ETags
+    should be matched.
+    """
+    if etag_str.strip() == '*':
+        return ['*']
+    else:
+        # Parse each ETag individually, and return any that are valid.
+        etag_matches = (ETAG_MATCH.match(etag.strip()) for etag in etag_str.split(','))
+        return [match.group(1) for match in etag_matches if match]
+
+
+def quote_etag(etag_str):
+    """
+    If the provided string is already a quoted ETag, return it. Otherwise, wrap
+    the string in quotes, making it a strong ETag.
+    """
+    if ETAG_MATCH.match(etag_str):
+        return etag_str
+    else:
+        return '"%s"' % etag_str
+
+
+def is_same_domain(host, pattern):
+    """
+    Return ``True`` if the host is either an exact match or a match
+    to the wildcard pattern.
+
+    Any pattern beginning with a period matches a domain and all of its
+    subdomains. (e.g. ``.example.com`` matches ``example.com`` and
+    ``foo.example.com``). Anything else is an exact string match.
+    """
+    if not pattern:
+        return False
+
+    pattern = pattern.lower()
+    return (
+        pattern[0] == '.' and (host.endswith(pattern) or host == pattern[1:]) or
+        pattern == host
+    )
+
+
+def is_safe_url(url, allowed_hosts, require_https=False):
+    """
+    Return ``True`` if the url is a safe redirection (i.e. it doesn't point to
+    a different host and uses a safe scheme).
+
+    Always return ``False`` on an empty url.
+
+    If ``require_https`` is ``True``, only 'https' will be considered a valid
+    scheme, as opposed to 'http' and 'https' with the default, ``False``.
+    """
+    if url is not None:
+        url = url.strip()
+    if not url:
+        return False
+    if allowed_hosts is None:
+        allowed_hosts = set()
+    elif isinstance(allowed_hosts, str):
+        allowed_hosts = {allowed_hosts}
+    # Chrome treats \ completely as / in paths but it could be part of some
+    # basic auth credentials so we need to check both URLs.
+    return (_is_safe_url(url, allowed_hosts, require_https=require_https) and
+            _is_safe_url(url.replace('\\', '/'), allowed_hosts, require_https=require_https))
+
+
+# Copied from urllib.parse.urlparse() but uses fixed urlsplit() function.
+def _urlparse(url, scheme='', allow_fragments=True):
+    """Parse a URL into 6 components:
+    <scheme>://<netloc>/<path>;<params>?<query>#<fragment>
+    Return a 6-tuple: (scheme, netloc, path, params, query, fragment).
+    Note that we don't break the components up in smaller bits
+    (e.g. netloc is a single string) and we don't expand % escapes."""
+    url, scheme, _coerce_result = _coerce_args(url, scheme)
+    splitresult = _urlsplit(url, scheme, allow_fragments)
+    scheme, netloc, url, query, fragment = splitresult
+    if scheme in uses_params and ';' in url:
+        url, params = _splitparams(url)
+    else:
+        params = ''
+    result = ParseResult(scheme, netloc, url, params, query, fragment)
+    return _coerce_result(result)
+
+
+# Copied from urllib.parse.urlsplit() with
+# https://github.com/python/cpython/pull/661 applied.
+def _urlsplit(url, scheme='', allow_fragments=True):
+    """Parse a URL into 5 components:
+    <scheme>://<netloc>/<path>?<query>#<fragment>
+    Return a 5-tuple: (scheme, netloc, path, query, fragment).
+    Note that we don't break the components up in smaller bits
+    (e.g. netloc is a single string) and we don't expand % escapes."""
+    url, scheme, _coerce_result = _coerce_args(url, scheme)
+    netloc = query = fragment = ''
+    i = url.find(':')
+    if i > 0:
+        for c in url[:i]:
+            if c not in scheme_chars:
+                break
+        else:
+            scheme, url = url[:i].lower(), url[i + 1:]
+
+    if url[:2] == '//':
+        netloc, url = _splitnetloc(url, 2)
+        if (('[' in netloc and ']' not in netloc) or
+                (']' in netloc and '[' not in netloc)):
+            raise ValueError("Invalid IPv6 URL")
+    if allow_fragments and '#' in url:
+        url, fragment = url.split('#', 1)
+    if '?' in url:
+        url, query = url.split('?', 1)
+    v = SplitResult(scheme, netloc, url, query, fragment)
+    return _coerce_result(v)
+
+
+def _is_safe_url(url, allowed_hosts, require_https=False):
+    # Chrome considers any URL with more than two slashes to be absolute, but
+    # urlparse is not so flexible. Treat any url with three slashes as unsafe.
+    if url.startswith('///'):
+        return False
+    try:
+        url_info = _urlparse(url)
+    except ValueError:  # e.g. invalid IPv6 addresses
+        return False
+    # Forbid URLs like http:///example.com - with a scheme, but without a hostname.
+    # In that URL, example.com is not the hostname but, a path component. However,
+    # Chrome will still consider example.com to be the hostname, so we must not
+    # allow this syntax.
+    if not url_info.netloc and url_info.scheme:
+        return False
+    # Forbid URLs that start with control characters. Some browsers (like
+    # Chrome) ignore quite a few control characters at the start of a
+    # URL and might consider the URL as scheme relative.
+    if unicodedata.category(url[0])[0] == 'C':
+        return False
+    scheme = url_info.scheme
+    # Consider URLs without a scheme (e.g. //example.com/p) to be http.
+    if not url_info.scheme and url_info.netloc:
+        scheme = 'http'
+    valid_schemes = ['https'] if require_https else ['http', 'https']
+    return ((not url_info.netloc or url_info.netloc in allowed_hosts) and
+            (not scheme or scheme in valid_schemes))
+
+
+def limited_parse_qsl(qs, keep_blank_values=False, encoding='utf-8',
+                      errors='replace', fields_limit=None):
+    """
+    Return a list of key/value tuples parsed from query string.
+
+    Copied from urlparse with an additional "fields_limit" argument.
+    Copyright (C) 2013 Python Software Foundation (see LICENSE.python).
+
+    Arguments:
+
+    qs: percent-encoded query string to be parsed
+
+    keep_blank_values: flag indicating whether blank values in
+        percent-encoded queries should be treated as blank strings. A
+        true value indicates that blanks should be retained as blank
+        strings. The default false value indicates that blank values
+        are to be ignored and treated as if they were  not included.
+
+    encoding and errors: specify how to decode percent-encoded sequences
+        into Unicode characters, as accepted by the bytes.decode() method.
+
+    fields_limit: maximum number of fields parsed or an exception
+        is raised. None means no limit and is the default.
+    """
+    if fields_limit:
+        pairs = FIELDS_MATCH.split(qs, fields_limit)
+        if len(pairs) > fields_limit:
+            raise TooManyFieldsSent(
+                'The number of GET/POST parameters exceeded '
+                'settings.DATA_UPLOAD_MAX_NUMBER_FIELDS.'
+            )
+    else:
+        pairs = FIELDS_MATCH.split(qs)
+    r = []
+    for name_value in pairs:
+        if not name_value:
+            continue
+        nv = name_value.split('=', 1)
+        if len(nv) != 2:
+            # Handle case of a control-name with no equal sign
+            if keep_blank_values:
+                nv.append('')
+            else:
+                continue
+        if nv[1] or keep_blank_values:
+            name = nv[0].replace('+', ' ')
+            name = unquote(name, encoding=encoding, errors=errors)
+            value = nv[1].replace('+', ' ')
+            value = unquote(value, encoding=encoding, errors=errors)
+            r.append((name, value))
+    return r
+
+
+def escape_leading_slashes(url):
+    """
+    If redirecting to an absolute path (two leading slashes), a slash must be
+    escaped to prevent browsers from handling the path as schemaless and
+    redirecting to another host.
+    """
+    if url.startswith('//'):
+        url = '/%2F{}'.format(url[2:])
+    return url

venv/lib/python3.7/site-packages/django/utils/ipv6.py

@@ -0,0 +1,46 @@
+import ipaddress
+
+from django.core.exceptions import ValidationError
+from django.utils.translation import gettext_lazy as _
+
+
+def clean_ipv6_address(ip_str, unpack_ipv4=False,
+                       error_message=_("This is not a valid IPv6 address.")):
+    """
+    Clean an IPv6 address string.
+
+    Raise ValidationError if the address is invalid.
+
+    Replace the longest continuous zero-sequence with "::", remove leading
+    zeroes, and make sure all hextets are lowercase.
+
+    Args:
+        ip_str: A valid IPv6 address.
+        unpack_ipv4: if an IPv4-mapped address is found,
+        return the plain IPv4 address (default=False).
+        error_message: An error message used in the ValidationError.
+
+    Return a compressed IPv6 address or the same value.
+    """
+    try:
+        addr = ipaddress.IPv6Address(int(ipaddress.IPv6Address(ip_str)))
+    except ValueError:
+        raise ValidationError(error_message, code='invalid')
+
+    if unpack_ipv4 and addr.ipv4_mapped:
+        return str(addr.ipv4_mapped)
+    elif addr.ipv4_mapped:
+        return '::ffff:%s' % str(addr.ipv4_mapped)
+
+    return str(addr)
+
+
+def is_valid_ipv6_address(ip_str):
+    """
+    Return whether or not the `ip_str` string is a valid IPv6 address.
+    """
+    try:
+        ipaddress.IPv6Address(ip_str)
+    except ValueError:
+        return False
+    return True

venv/lib/python3.7/site-packages/django/utils/jslex.py

@@ -0,0 +1,220 @@
+"""JsLex: a lexer for Javascript"""
+# Originally from https://bitbucket.org/ned/jslex
+import re
+
+
+class Tok:
+    """
+    A specification for a token class.
+    """
+    num = 0
+
+    def __init__(self, name, regex, next=None):
+        self.id = Tok.num
+        Tok.num += 1
+        self.name = name
+        self.regex = regex
+        self.next = next
+
+
+def literals(choices, prefix="", suffix=""):
+    """
+    Create a regex from a space-separated list of literal `choices`.
+
+    If provided, `prefix` and `suffix` will be attached to each choice
+    individually.
+    """
+    return "|".join(prefix + re.escape(c) + suffix for c in choices.split())
+
+
+class Lexer:
+    """
+    A generic multi-state regex-based lexer.
+    """
+
+    def __init__(self, states, first):
+        self.regexes = {}
+        self.toks = {}
+
+        for state, rules in states.items():
+            parts = []
+            for tok in rules:
+                groupid = "t%d" % tok.id
+                self.toks[groupid] = tok
+                parts.append("(?P<%s>%s)" % (groupid, tok.regex))
+            self.regexes[state] = re.compile("|".join(parts), re.MULTILINE | re.VERBOSE)
+
+        self.state = first
+
+    def lex(self, text):
+        """
+        Lexically analyze `text`.
+
+        Yield pairs (`name`, `tokentext`).
+        """
+        end = len(text)
+        state = self.state
+        regexes = self.regexes
+        toks = self.toks
+        start = 0
+
+        while start < end:
+            for match in regexes[state].finditer(text, start):
+                name = match.lastgroup
+                tok = toks[name]
+                toktext = match.group(name)
+                start += len(toktext)
+                yield (tok.name, toktext)
+
+                if tok.next:
+                    state = tok.next
+                    break
+
+        self.state = state
+
+
+class JsLexer(Lexer):
+    """
+    A Javascript lexer
+
+    >>> lexer = JsLexer()
+    >>> list(lexer.lex("a = 1"))
+    [('id', 'a'), ('ws', ' '), ('punct', '='), ('ws', ' '), ('dnum', '1')]
+
+    This doesn't properly handle non-ASCII characters in the Javascript source.
+    """
+
+    # Because these tokens are matched as alternatives in a regex, longer
+    # possibilities must appear in the list before shorter ones, for example,
+    # '>>' before '>'.
+    #
+    # Note that we don't have to detect malformed Javascript, only properly
+    # lex correct Javascript, so much of this is simplified.
+
+    # Details of Javascript lexical structure are taken from
+    # http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-262.pdf
+
+    # A useful explanation of automatic semicolon insertion is at
+    # http://inimino.org/~inimino/blog/javascript_semicolons
+
+    both_before = [
+        Tok("comment", r"/\*(.|\n)*?\*/"),
+        Tok("linecomment", r"//.*?$"),
+        Tok("ws", r"\s+"),
+        Tok("keyword", literals("""
+                           break case catch class const continue debugger
+                           default delete do else enum export extends
+                           finally for function if import in instanceof
+                           new return super switch this throw try typeof
+                           var void while with
+                           """, suffix=r"\b"), next='reg'),
+        Tok("reserved", literals("null true false", suffix=r"\b"), next='div'),
+        Tok("id", r"""
+                  ([a-zA-Z_$   ]|\\u[0-9a-fA-Z]{4})   # first char
+                  ([a-zA-Z_$0-9]|\\u[0-9a-fA-F]{4})*  # rest chars
+                  """, next='div'),
+        Tok("hnum", r"0[xX][0-9a-fA-F]+", next='div'),
+        Tok("onum", r"0[0-7]+"),
+        Tok("dnum", r"""
+                    (   (0|[1-9][0-9]*)     # DecimalIntegerLiteral
+                        \.                  # dot
+                        [0-9]*              # DecimalDigits-opt
+                        ([eE][-+]?[0-9]+)?  # ExponentPart-opt
+                    |
+                        \.                  # dot
+                        [0-9]+              # DecimalDigits
+                        ([eE][-+]?[0-9]+)?  # ExponentPart-opt
+                    |
+                        (0|[1-9][0-9]*)     # DecimalIntegerLiteral
+                        ([eE][-+]?[0-9]+)?  # ExponentPart-opt
+                    )
+                    """, next='div'),
+        Tok("punct", literals("""
+                         >>>= === !== >>> <<= >>= <= >= == != << >> &&
+                         || += -= *= %= &= |= ^=
+                         """), next="reg"),
+        Tok("punct", literals("++ -- ) ]"), next='div'),
+        Tok("punct", literals("{ } ( [ . ; , < > + - * % & | ^ ! ~ ? : ="), next='reg'),
+        Tok("string", r'"([^"\\]|(\\(.|\n)))*?"', next='div'),
+        Tok("string", r"'([^'\\]|(\\(.|\n)))*?'", next='div'),
+    ]
+
+    both_after = [
+        Tok("other", r"."),
+    ]
+
+    states = {
+        # slash will mean division
+        'div': both_before + [
+            Tok("punct", literals("/= /"), next='reg'),
+        ] + both_after,
+
+        # slash will mean regex
+        'reg': both_before + [
+            Tok("regex",
+                r"""
+                    /                       # opening slash
+                    # First character is..
+                    (   [^*\\/[]            # anything but * \ / or [
+                    |   \\.                 # or an escape sequence
+                    |   \[                  # or a class, which has
+                            (   [^\]\\]     #   anything but \ or ]
+                            |   \\.         #   or an escape sequence
+                            )*              #   many times
+                        \]
+                    )
+                    # Following characters are same, except for excluding a star
+                    (   [^\\/[]             # anything but \ / or [
+                    |   \\.                 # or an escape sequence
+                    |   \[                  # or a class, which has
+                            (   [^\]\\]     #   anything but \ or ]
+                            |   \\.         #   or an escape sequence
+                            )*              #   many times
+                        \]
+                    )*                      # many times
+                    /                       # closing slash
+                    [a-zA-Z0-9]*            # trailing flags
+                """, next='div'),
+        ] + both_after,
+    }
+
+    def __init__(self):
+        super().__init__(self.states, 'reg')
+
+
+def prepare_js_for_gettext(js):
+    """
+    Convert the Javascript source `js` into something resembling C for
+    xgettext.
+
+    What actually happens is that all the regex literals are replaced with
+    "REGEX".
+    """
+    def escape_quotes(m):
+        """Used in a regex to properly escape double quotes."""
+        s = m.group(0)
+        if s == '"':
+            return r'\"'
+        else:
+            return s
+
+    lexer = JsLexer()
+    c = []
+    for name, tok in lexer.lex(js):
+        if name == 'regex':
+            # C doesn't grok regexes, and they aren't needed for gettext,
+            # so just output a string instead.
+            tok = '"REGEX"'
+        elif name == 'string':
+            # C doesn't have single-quoted strings, so make all strings
+            # double-quoted.
+            if tok.startswith("'"):
+                guts = re.sub(r"\\.|.", escape_quotes, tok[1:-1])
+                tok = '"' + guts + '"'
+        elif name == 'id':
+            # C can't deal with Unicode escapes in identifiers.  We don't
+            # need them for gettext anyway, so replace them with something
+            # innocuous
+            tok = tok.replace("\\", "U")
+        c.append(tok)
+    return ''.join(c)

venv/lib/python3.7/site-packages/django/utils/lorem_ipsum.py

@@ -0,0 +1,114 @@
+"""
+Utility functions for generating "lorem ipsum" Latin text.
+"""
+
+import random
+
+COMMON_P = (
+    'Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod '
+    'tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim '
+    'veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea '
+    'commodo consequat. Duis aute irure dolor in reprehenderit in voluptate '
+    'velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint '
+    'occaecat cupidatat non proident, sunt in culpa qui officia deserunt '
+    'mollit anim id est laborum.'
+)
+
+WORDS = (
+    'exercitationem', 'perferendis', 'perspiciatis', 'laborum', 'eveniet',
+    'sunt', 'iure', 'nam', 'nobis', 'eum', 'cum', 'officiis', 'excepturi',
+    'odio', 'consectetur', 'quasi', 'aut', 'quisquam', 'vel', 'eligendi',
+    'itaque', 'non', 'odit', 'tempore', 'quaerat', 'dignissimos',
+    'facilis', 'neque', 'nihil', 'expedita', 'vitae', 'vero', 'ipsum',
+    'nisi', 'animi', 'cumque', 'pariatur', 'velit', 'modi', 'natus',
+    'iusto', 'eaque', 'sequi', 'illo', 'sed', 'ex', 'et', 'voluptatibus',
+    'tempora', 'veritatis', 'ratione', 'assumenda', 'incidunt', 'nostrum',
+    'placeat', 'aliquid', 'fuga', 'provident', 'praesentium', 'rem',
+    'necessitatibus', 'suscipit', 'adipisci', 'quidem', 'possimus',
+    'voluptas', 'debitis', 'sint', 'accusantium', 'unde', 'sapiente',
+    'voluptate', 'qui', 'aspernatur', 'laudantium', 'soluta', 'amet',
+    'quo', 'aliquam', 'saepe', 'culpa', 'libero', 'ipsa', 'dicta',
+    'reiciendis', 'nesciunt', 'doloribus', 'autem', 'impedit', 'minima',
+    'maiores', 'repudiandae', 'ipsam', 'obcaecati', 'ullam', 'enim',
+    'totam', 'delectus', 'ducimus', 'quis', 'voluptates', 'dolores',
+    'molestiae', 'harum', 'dolorem', 'quia', 'voluptatem', 'molestias',
+    'magni', 'distinctio', 'omnis', 'illum', 'dolorum', 'voluptatum', 'ea',
+    'quas', 'quam', 'corporis', 'quae', 'blanditiis', 'atque', 'deserunt',
+    'laboriosam', 'earum', 'consequuntur', 'hic', 'cupiditate',
+    'quibusdam', 'accusamus', 'ut', 'rerum', 'error', 'minus', 'eius',
+    'ab', 'ad', 'nemo', 'fugit', 'officia', 'at', 'in', 'id', 'quos',
+    'reprehenderit', 'numquam', 'iste', 'fugiat', 'sit', 'inventore',
+    'beatae', 'repellendus', 'magnam', 'recusandae', 'quod', 'explicabo',
+    'doloremque', 'aperiam', 'consequatur', 'asperiores', 'commodi',
+    'optio', 'dolor', 'labore', 'temporibus', 'repellat', 'veniam',
+    'architecto', 'est', 'esse', 'mollitia', 'nulla', 'a', 'similique',
+    'eos', 'alias', 'dolore', 'tenetur', 'deleniti', 'porro', 'facere',
+    'maxime', 'corrupti',
+)
+
+COMMON_WORDS = (
+    'lorem', 'ipsum', 'dolor', 'sit', 'amet', 'consectetur',
+    'adipisicing', 'elit', 'sed', 'do', 'eiusmod', 'tempor', 'incididunt',
+    'ut', 'labore', 'et', 'dolore', 'magna', 'aliqua',
+)
+
+
+def sentence():
+    """
+    Return a randomly generated sentence of lorem ipsum text.
+
+    The first word is capitalized, and the sentence ends in either a period or
+    question mark. Commas are added at random.
+    """
+    # Determine the number of comma-separated sections and number of words in
+    # each section for this sentence.
+    sections = [' '.join(random.sample(WORDS, random.randint(3, 12))) for i in range(random.randint(1, 5))]
+    s = ', '.join(sections)
+    # Convert to sentence case and add end punctuation.
+    return '%s%s%s' % (s[0].upper(), s[1:], random.choice('?.'))
+
+
+def paragraph():
+    """
+    Return a randomly generated paragraph of lorem ipsum text.
+
+    The paragraph consists of between 1 and 4 sentences, inclusive.
+    """
+    return ' '.join(sentence() for i in range(random.randint(1, 4)))
+
+
+def paragraphs(count, common=True):
+    """
+    Return a list of paragraphs as returned by paragraph().
+
+    If `common` is True, then the first paragraph will be the standard
+    'lorem ipsum' paragraph. Otherwise, the first paragraph will be random
+    Latin text. Either way, subsequent paragraphs will be random Latin text.
+    """
+    paras = []
+    for i in range(count):
+        if common and i == 0:
+            paras.append(COMMON_P)
+        else:
+            paras.append(paragraph())
+    return paras
+
+
+def words(count, common=True):
+    """
+    Return a string of `count` lorem ipsum words separated by a single space.
+
+    If `common` is True, then the first 19 words will be the standard
+    'lorem ipsum' words. Otherwise, all words will be selected randomly.
+    """
+    word_list = list(COMMON_WORDS) if common else []
+    c = len(word_list)
+    if count > c:
+        count -= c
+        while count > 0:
+            c = min(count, len(WORDS))
+            count -= c
+            word_list += random.sample(WORDS, c)
+    else:
+        word_list = word_list[:count]
+    return ' '.join(word_list)

venv/lib/python3.7/site-packages/django/utils/module_loading.py

@@ -0,0 +1,98 @@
+import copy
+import os
+from importlib import import_module
+from importlib.util import find_spec as importlib_find
+
+
+def import_string(dotted_path):
+    """
+    Import a dotted module path and return the attribute/class designated by the
+    last name in the path. Raise ImportError if the import failed.
+    """
+    try:
+        module_path, class_name = dotted_path.rsplit('.', 1)
+    except ValueError as err:
+        raise ImportError("%s doesn't look like a module path" % dotted_path) from err
+
+    module = import_module(module_path)
+
+    try:
+        return getattr(module, class_name)
+    except AttributeError as err:
+        raise ImportError('Module "%s" does not define a "%s" attribute/class' % (
+            module_path, class_name)
+        ) from err
+
+
+def autodiscover_modules(*args, **kwargs):
+    """
+    Auto-discover INSTALLED_APPS modules and fail silently when
+    not present. This forces an import on them to register any admin bits they
+    may want.
+
+    You may provide a register_to keyword parameter as a way to access a
+    registry. This register_to object must have a _registry instance variable
+    to access it.
+    """
+    from django.apps import apps
+
+    register_to = kwargs.get('register_to')
+    for app_config in apps.get_app_configs():
+        for module_to_search in args:
+            # Attempt to import the app's module.
+            try:
+                if register_to:
+                    before_import_registry = copy.copy(register_to._registry)
+
+                import_module('%s.%s' % (app_config.name, module_to_search))
+            except Exception:
+                # Reset the registry to the state before the last import
+                # as this import will have to reoccur on the next request and
+                # this could raise NotRegistered and AlreadyRegistered
+                # exceptions (see #8245).
+                if register_to:
+                    register_to._registry = before_import_registry
+
+                # Decide whether to bubble up this error. If the app just
+                # doesn't have the module in question, we can ignore the error
+                # attempting to import it, otherwise we want it to bubble up.
+                if module_has_submodule(app_config.module, module_to_search):
+                    raise
+
+
+def module_has_submodule(package, module_name):
+    """See if 'module' is in 'package'."""
+    try:
+        package_name = package.__name__
+        package_path = package.__path__
+    except AttributeError:
+        # package isn't a package.
+        return False
+
+    full_module_name = package_name + '.' + module_name
+    try:
+        return importlib_find(full_module_name, package_path) is not None
+    except (ImportError, AttributeError):
+        # When module_name is an invalid dotted path, Python raises ImportError
+        # (or ModuleNotFoundError in Python 3.6+). AttributeError may be raised
+        # if the penultimate part of the path is not a package.
+        # (https://bugs.python.org/issue30436)
+        return False
+
+
+def module_dir(module):
+    """
+    Find the name of the directory that contains a module, if possible.
+
+    Raise ValueError otherwise, e.g. for namespace packages that are split
+    over several directories.
+    """
+    # Convert to list because _NamespacePath does not support indexing on 3.3.
+    paths = list(getattr(module, '__path__', []))
+    if len(paths) == 1:
+        return paths[0]
+    else:
+        filename = getattr(module, '__file__', None)
+        if filename is not None:
+            return os.path.dirname(filename)
+    raise ValueError("Cannot determine directory containing %s" % module)

venv/lib/python3.7/site-packages/django/utils/numberformat.py

@@ -0,0 +1,79 @@
+from decimal import Decimal
+
+from django.conf import settings
+from django.utils.safestring import mark_safe
+
+
+def format(number, decimal_sep, decimal_pos=None, grouping=0, thousand_sep='',
+           force_grouping=False, use_l10n=None):
+    """
+    Get a number (as a number or string), and return it as a string,
+    using formats defined as arguments:
+
+    * decimal_sep: Decimal separator symbol (for example ".")
+    * decimal_pos: Number of decimal positions
+    * grouping: Number of digits in every group limited by thousand separator.
+        For non-uniform digit grouping, it can be a sequence with the number
+        of digit group sizes following the format used by the Python locale
+        module in locale.localeconv() LC_NUMERIC grouping (e.g. (3, 2, 0)).
+    * thousand_sep: Thousand separator symbol (for example ",")
+    """
+    use_grouping = (use_l10n or (use_l10n is None and settings.USE_L10N)) and settings.USE_THOUSAND_SEPARATOR
+    use_grouping = use_grouping or force_grouping
+    use_grouping = use_grouping and grouping != 0
+    # Make the common case fast
+    if isinstance(number, int) and not use_grouping and not decimal_pos:
+        return mark_safe(number)
+    # sign
+    sign = ''
+    if isinstance(number, Decimal):
+        # Format values with more than 200 digits (an arbitrary cutoff) using
+        # scientific notation to avoid high memory usage in {:f}'.format().
+        _, digits, exponent = number.as_tuple()
+        if abs(exponent) + len(digits) > 200:
+            number = '{:e}'.format(number)
+            coefficient, exponent = number.split('e')
+            # Format the coefficient.
+            coefficient = format(
+                coefficient, decimal_sep, decimal_pos, grouping,
+                thousand_sep, force_grouping, use_l10n,
+            )
+            return '{}e{}'.format(coefficient, exponent)
+        else:
+            str_number = '{:f}'.format(number)
+    else:
+        str_number = str(number)
+    if str_number[0] == '-':
+        sign = '-'
+        str_number = str_number[1:]
+    # decimal part
+    if '.' in str_number:
+        int_part, dec_part = str_number.split('.')
+        if decimal_pos is not None:
+            dec_part = dec_part[:decimal_pos]
+    else:
+        int_part, dec_part = str_number, ''
+    if decimal_pos is not None:
+        dec_part = dec_part + ('0' * (decimal_pos - len(dec_part)))
+    dec_part = dec_part and decimal_sep + dec_part
+    # grouping
+    if use_grouping:
+        try:
+            # if grouping is a sequence
+            intervals = list(grouping)
+        except TypeError:
+            # grouping is a single value
+            intervals = [grouping, 0]
+        active_interval = intervals.pop(0)
+        int_part_gd = ''
+        cnt = 0
+        for digit in int_part[::-1]:
+            if cnt and cnt == active_interval:
+                if intervals:
+                    active_interval = intervals.pop(0) or active_interval
+                int_part_gd += thousand_sep[::-1]
+                cnt = 0
+            int_part_gd += digit
+            cnt += 1
+        int_part = int_part_gd[::-1]
+    return sign + int_part + dec_part

venv/lib/python3.7/site-packages/django/utils/safestring.py

@@ -0,0 +1,84 @@
+"""
+Functions for working with "safe strings": strings that can be displayed safely
+without further escaping in HTML. Marking something as a "safe string" means
+that the producer of the string has already turned characters that should not
+be interpreted by the HTML engine (e.g. '<') into the appropriate entities.
+"""
+
+from django.utils.functional import wraps
+
+
+class SafeData:
+    def __html__(self):
+        """
+        Return the html representation of a string for interoperability.
+
+        This allows other template engines to understand Django's SafeData.
+        """
+        return self
+
+
+class SafeBytes(bytes, SafeData):
+    """
+    A bytes subclass that has been specifically marked as "safe" (requires no
+    further escaping) for HTML output purposes.
+
+    Kept in Django 2.0 for usage by apps supporting Python 2. Shouldn't be used
+    in Django anymore.
+    """
+    def __add__(self, rhs):
+        """
+        Concatenating a safe byte string with another safe byte string or safe
+        string is safe. Otherwise, the result is no longer safe.
+        """
+        t = super().__add__(rhs)
+        if isinstance(rhs, SafeText):
+            return SafeText(t)
+        elif isinstance(rhs, SafeBytes):
+            return SafeBytes(t)
+        return t
+
+
+class SafeText(str, SafeData):
+    """
+    A str subclass that has been specifically marked as "safe" for HTML output
+    purposes.
+    """
+    def __add__(self, rhs):
+        """
+        Concatenating a safe string with another safe bytestring or
+        safe string is safe. Otherwise, the result is no longer safe.
+        """
+        t = super().__add__(rhs)
+        if isinstance(rhs, SafeData):
+            return SafeText(t)
+        return t
+
+    def __str__(self):
+        return self
+
+
+SafeString = SafeText
+
+
+def _safety_decorator(safety_marker, func):
+    @wraps(func)
+    def wrapped(*args, **kwargs):
+        return safety_marker(func(*args, **kwargs))
+    return wrapped
+
+
+def mark_safe(s):
+    """
+    Explicitly mark a string as safe for (HTML) output purposes. The returned
+    object can be used everywhere a string is appropriate.
+
+    If used on a method as a decorator, mark the returned data as safe.
+
+    Can be called multiple times on a single string.
+    """
+    if hasattr(s, '__html__'):
+        return s
+    if callable(s):
+        return _safety_decorator(mark_safe, s)
+    return SafeText(s)

venv/lib/python3.7/site-packages/django/utils/termcolors.py

@@ -0,0 +1,215 @@
+"""
+termcolors.py
+"""
+
+color_names = ('black', 'red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white')
+foreground = {color_names[x]: '3%s' % x for x in range(8)}
+background = {color_names[x]: '4%s' % x for x in range(8)}
+
+RESET = '0'
+opt_dict = {'bold': '1', 'underscore': '4', 'blink': '5', 'reverse': '7', 'conceal': '8'}
+
+
+def colorize(text='', opts=(), **kwargs):
+    """
+    Return your text, enclosed in ANSI graphics codes.
+
+    Depends on the keyword arguments 'fg' and 'bg', and the contents of
+    the opts tuple/list.
+
+    Return the RESET code if no parameters are given.
+
+    Valid colors:
+        'black', 'red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white'
+
+    Valid options:
+        'bold'
+        'underscore'
+        'blink'
+        'reverse'
+        'conceal'
+        'noreset' - string will not be auto-terminated with the RESET code
+
+    Examples:
+        colorize('hello', fg='red', bg='blue', opts=('blink',))
+        colorize()
+        colorize('goodbye', opts=('underscore',))
+        print(colorize('first line', fg='red', opts=('noreset',)))
+        print('this should be red too')
+        print(colorize('and so should this'))
+        print('this should not be red')
+    """
+    code_list = []
+    if text == '' and len(opts) == 1 and opts[0] == 'reset':
+        return '\x1b[%sm' % RESET
+    for k, v in kwargs.items():
+        if k == 'fg':
+            code_list.append(foreground[v])
+        elif k == 'bg':
+            code_list.append(background[v])
+    for o in opts:
+        if o in opt_dict:
+            code_list.append(opt_dict[o])
+    if 'noreset' not in opts:
+        text = '%s\x1b[%sm' % (text or '', RESET)
+    return '%s%s' % (('\x1b[%sm' % ';'.join(code_list)), text or '')
+
+
+def make_style(opts=(), **kwargs):
+    """
+    Return a function with default parameters for colorize()
+
+    Example:
+        bold_red = make_style(opts=('bold',), fg='red')
+        print(bold_red('hello'))
+        KEYWORD = make_style(fg='yellow')
+        COMMENT = make_style(fg='blue', opts=('bold',))
+    """
+    return lambda text: colorize(text, opts, **kwargs)
+
+
+NOCOLOR_PALETTE = 'nocolor'
+DARK_PALETTE = 'dark'
+LIGHT_PALETTE = 'light'
+
+PALETTES = {
+    NOCOLOR_PALETTE: {
+        'ERROR': {},
+        'SUCCESS': {},
+        'WARNING': {},
+        'NOTICE': {},
+        'SQL_FIELD': {},
+        'SQL_COLTYPE': {},
+        'SQL_KEYWORD': {},
+        'SQL_TABLE': {},
+        'HTTP_INFO': {},
+        'HTTP_SUCCESS': {},
+        'HTTP_REDIRECT': {},
+        'HTTP_NOT_MODIFIED': {},
+        'HTTP_BAD_REQUEST': {},
+        'HTTP_NOT_FOUND': {},
+        'HTTP_SERVER_ERROR': {},
+        'MIGRATE_HEADING': {},
+        'MIGRATE_LABEL': {},
+    },
+    DARK_PALETTE: {
+        'ERROR': {'fg': 'red', 'opts': ('bold',)},
+        'SUCCESS': {'fg': 'green', 'opts': ('bold',)},
+        'WARNING': {'fg': 'yellow', 'opts': ('bold',)},
+        'NOTICE': {'fg': 'red'},
+        'SQL_FIELD': {'fg': 'green', 'opts': ('bold',)},
+        'SQL_COLTYPE': {'fg': 'green'},
+        'SQL_KEYWORD': {'fg': 'yellow'},
+        'SQL_TABLE': {'opts': ('bold',)},
+        'HTTP_INFO': {'opts': ('bold',)},
+        'HTTP_SUCCESS': {},
+        'HTTP_REDIRECT': {'fg': 'green'},
+        'HTTP_NOT_MODIFIED': {'fg': 'cyan'},
+        'HTTP_BAD_REQUEST': {'fg': 'red', 'opts': ('bold',)},
+        'HTTP_NOT_FOUND': {'fg': 'yellow'},
+        'HTTP_SERVER_ERROR': {'fg': 'magenta', 'opts': ('bold',)},
+        'MIGRATE_HEADING': {'fg': 'cyan', 'opts': ('bold',)},
+        'MIGRATE_LABEL': {'opts': ('bold',)},
+    },
+    LIGHT_PALETTE: {
+        'ERROR': {'fg': 'red', 'opts': ('bold',)},
+        'SUCCESS': {'fg': 'green', 'opts': ('bold',)},
+        'WARNING': {'fg': 'yellow', 'opts': ('bold',)},
+        'NOTICE': {'fg': 'red'},
+        'SQL_FIELD': {'fg': 'green', 'opts': ('bold',)},
+        'SQL_COLTYPE': {'fg': 'green'},
+        'SQL_KEYWORD': {'fg': 'blue'},
+        'SQL_TABLE': {'opts': ('bold',)},
+        'HTTP_INFO': {'opts': ('bold',)},
+        'HTTP_SUCCESS': {},
+        'HTTP_REDIRECT': {'fg': 'green', 'opts': ('bold',)},
+        'HTTP_NOT_MODIFIED': {'fg': 'green'},
+        'HTTP_BAD_REQUEST': {'fg': 'red', 'opts': ('bold',)},
+        'HTTP_NOT_FOUND': {'fg': 'red'},
+        'HTTP_SERVER_ERROR': {'fg': 'magenta', 'opts': ('bold',)},
+        'MIGRATE_HEADING': {'fg': 'cyan', 'opts': ('bold',)},
+        'MIGRATE_LABEL': {'opts': ('bold',)},
+    }
+}
+DEFAULT_PALETTE = DARK_PALETTE
+
+
+def parse_color_setting(config_string):
+    """Parse a DJANGO_COLORS environment variable to produce the system palette
+
+    The general form of a palette definition is:
+
+        "palette;role=fg;role=fg/bg;role=fg,option,option;role=fg/bg,option,option"
+
+    where:
+        palette is a named palette; one of 'light', 'dark', or 'nocolor'.
+        role is a named style used by Django
+        fg is a background color.
+        bg is a background color.
+        option is a display options.
+
+    Specifying a named palette is the same as manually specifying the individual
+    definitions for each role. Any individual definitions following the palette
+    definition will augment the base palette definition.
+
+    Valid roles:
+        'error', 'success', 'warning', 'notice', 'sql_field', 'sql_coltype',
+        'sql_keyword', 'sql_table', 'http_info', 'http_success',
+        'http_redirect', 'http_not_modified', 'http_bad_request',
+        'http_not_found', 'http_server_error', 'migrate_heading',
+        'migrate_label'
+
+    Valid colors:
+        'black', 'red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white'
+
+    Valid options:
+        'bold', 'underscore', 'blink', 'reverse', 'conceal', 'noreset'
+    """
+    if not config_string:
+        return PALETTES[DEFAULT_PALETTE]
+
+    # Split the color configuration into parts
+    parts = config_string.lower().split(';')
+    palette = PALETTES[NOCOLOR_PALETTE].copy()
+    for part in parts:
+        if part in PALETTES:
+            # A default palette has been specified
+            palette.update(PALETTES[part])
+        elif '=' in part:
+            # Process a palette defining string
+            definition = {}
+
+            # Break the definition into the role,
+            # plus the list of specific instructions.
+            # The role must be in upper case
+            role, instructions = part.split('=')
+            role = role.upper()
+
+            styles = instructions.split(',')
+            styles.reverse()
+
+            # The first instruction can contain a slash
+            # to break apart fg/bg.
+            colors = styles.pop().split('/')
+            colors.reverse()
+            fg = colors.pop()
+            if fg in color_names:
+                definition['fg'] = fg
+            if colors and colors[-1] in color_names:
+                definition['bg'] = colors[-1]
+
+            # All remaining instructions are options
+            opts = tuple(s for s in styles if s in opt_dict)
+            if opts:
+                definition['opts'] = opts
+
+            # The nocolor palette has all available roles.
+            # Use that palette as the basis for determining
+            # if the role is valid.
+            if role in PALETTES[NOCOLOR_PALETTE] and definition:
+                palette[role] = definition
+
+    # If there are no colors specified, return the empty palette.
+    if palette == PALETTES[NOCOLOR_PALETTE]:
+        return None
+    return palette

venv/lib/python3.7/site-packages/django/utils/timesince.py

@@ -0,0 +1,91 @@
+import calendar
+import datetime
+
+from django.utils.html import avoid_wrapping
+from django.utils.timezone import is_aware, utc
+from django.utils.translation import gettext, ngettext_lazy
+
+TIME_STRINGS = {
+    'year': ngettext_lazy('%d year', '%d years'),
+    'month': ngettext_lazy('%d month', '%d months'),
+    'week': ngettext_lazy('%d week', '%d weeks'),
+    'day': ngettext_lazy('%d day', '%d days'),
+    'hour': ngettext_lazy('%d hour', '%d hours'),
+    'minute': ngettext_lazy('%d minute', '%d minutes'),
+}
+
+TIMESINCE_CHUNKS = (
+    (60 * 60 * 24 * 365, 'year'),
+    (60 * 60 * 24 * 30, 'month'),
+    (60 * 60 * 24 * 7, 'week'),
+    (60 * 60 * 24, 'day'),
+    (60 * 60, 'hour'),
+    (60, 'minute'),
+)
+
+
+def timesince(d, now=None, reversed=False, time_strings=None):
+    """
+    Take two datetime objects and return the time between d and now as a nicely
+    formatted string, e.g. "10 minutes". If d occurs after now, return
+    "0 minutes".
+
+    Units used are years, months, weeks, days, hours, and minutes.
+    Seconds and microseconds are ignored.  Up to two adjacent units will be
+    displayed.  For example, "2 weeks, 3 days" and "1 year, 3 months" are
+    possible outputs, but "2 weeks, 3 hours" and "1 year, 5 days" are not.
+
+    `time_strings` is an optional dict of strings to replace the default
+    TIME_STRINGS dict.
+
+    Adapted from
+    https://web.archive.org/web/20060617175230/http://blog.natbat.co.uk/archive/2003/Jun/14/time_since
+    """
+    if time_strings is None:
+        time_strings = TIME_STRINGS
+
+    # Convert datetime.date to datetime.datetime for comparison.
+    if not isinstance(d, datetime.datetime):
+        d = datetime.datetime(d.year, d.month, d.day)
+    if now and not isinstance(now, datetime.datetime):
+        now = datetime.datetime(now.year, now.month, now.day)
+
+    now = now or datetime.datetime.now(utc if is_aware(d) else None)
+
+    if reversed:
+        d, now = now, d
+    delta = now - d
+
+    # Deal with leapyears by subtracing the number of leapdays
+    leapdays = calendar.leapdays(d.year, now.year)
+    if leapdays != 0:
+        if calendar.isleap(d.year):
+            leapdays -= 1
+        elif calendar.isleap(now.year):
+            leapdays += 1
+    delta -= datetime.timedelta(leapdays)
+
+    # ignore microseconds
+    since = delta.days * 24 * 60 * 60 + delta.seconds
+    if since <= 0:
+        # d is in the future compared to now, stop processing.
+        return avoid_wrapping(gettext('0 minutes'))
+    for i, (seconds, name) in enumerate(TIMESINCE_CHUNKS):
+        count = since // seconds
+        if count != 0:
+            break
+    result = avoid_wrapping(time_strings[name] % count)
+    if i + 1 < len(TIMESINCE_CHUNKS):
+        # Now get the second item
+        seconds2, name2 = TIMESINCE_CHUNKS[i + 1]
+        count2 = (since - (seconds * count)) // seconds2
+        if count2 != 0:
+            result += gettext(', ') + avoid_wrapping(time_strings[name2] % count2)
+    return result
+
+
+def timeuntil(d, now=None, time_strings=None):
+    """
+    Like timesince, but return a string measuring the time until the given time.
+    """
+    return timesince(d, now, reversed=True, time_strings=time_strings)

venv/lib/python3.7/site-packages/django/utils/translation/reloader.py

@@ -0,0 +1,28 @@
+import threading
+from pathlib import Path
+
+from django.apps import apps
+
+
+def watch_for_translation_changes(sender, **kwargs):
+    """Register file watchers for .mo files in potential locale paths."""
+    from django.conf import settings
+
+    if settings.USE_I18N:
+        directories = [Path('locale')]
+        directories.extend(Path(config.path) / 'locale' for config in apps.get_app_configs())
+        directories.extend(Path(p) for p in settings.LOCALE_PATHS)
+        for path in directories:
+            sender.watch_dir(path, '**/*.mo')
+
+
+def translation_file_changed(sender, file_path, **kwargs):
+    """Clear the internal translations cache if a .mo file is modified."""
+    if file_path.suffix == '.mo':
+        import gettext
+        from django.utils.translation import trans_real
+        gettext._translations = {}
+        trans_real._translations = {}
+        trans_real._default = None
+        trans_real._active = threading.local()
+        return True

venv/lib/python3.7/site-packages/django/utils/version.py

@@ -0,0 +1,104 @@
+import datetime
+import functools
+import os
+import subprocess
+import sys
+from distutils.version import LooseVersion
+
+# Private, stable API for detecting the Python version. PYXY means "Python X.Y
+# or later". So that third-party apps can use these values, each constant
+# should remain as long as the oldest supported Django version supports that
+# Python version.
+PY36 = sys.version_info >= (3, 6)
+PY37 = sys.version_info >= (3, 7)
+PY38 = sys.version_info >= (3, 8)
+PY39 = sys.version_info >= (3, 9)
+
+
+def get_version(version=None):
+    """Return a PEP 440-compliant version number from VERSION."""
+    version = get_complete_version(version)
+
+    # Now build the two parts of the version number:
+    # main = X.Y[.Z]
+    # sub = .devN - for pre-alpha releases
+    #     | {a|b|rc}N - for alpha, beta, and rc releases
+
+    main = get_main_version(version)
+
+    sub = ''
+    if version[3] == 'alpha' and version[4] == 0:
+        git_changeset = get_git_changeset()
+        if git_changeset:
+            sub = '.dev%s' % git_changeset
+
+    elif version[3] != 'final':
+        mapping = {'alpha': 'a', 'beta': 'b', 'rc': 'rc'}
+        sub = mapping[version[3]] + str(version[4])
+
+    return main + sub
+
+
+def get_main_version(version=None):
+    """Return main version (X.Y[.Z]) from VERSION."""
+    version = get_complete_version(version)
+    parts = 2 if version[2] == 0 else 3
+    return '.'.join(str(x) for x in version[:parts])
+
+
+def get_complete_version(version=None):
+    """
+    Return a tuple of the django version. If version argument is non-empty,
+    check for correctness of the tuple provided.
+    """
+    if version is None:
+        from django import VERSION as version
+    else:
+        assert len(version) == 5
+        assert version[3] in ('alpha', 'beta', 'rc', 'final')
+
+    return version
+
+
+def get_docs_version(version=None):
+    version = get_complete_version(version)
+    if version[3] != 'final':
+        return 'dev'
+    else:
+        return '%d.%d' % version[:2]
+
+
+@functools.lru_cache()
+def get_git_changeset():
+    """Return a numeric identifier of the latest git changeset.
+
+    The result is the UTC timestamp of the changeset in YYYYMMDDHHMMSS format.
+    This value isn't guaranteed to be unique, but collisions are very unlikely,
+    so it's sufficient for generating the development version numbers.
+    """
+    repo_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    git_log = subprocess.Popen(
+        'git log --pretty=format:%ct --quiet -1 HEAD',
+        stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+        shell=True, cwd=repo_dir, universal_newlines=True,
+    )
+    timestamp = git_log.communicate()[0]
+    try:
+        timestamp = datetime.datetime.utcfromtimestamp(int(timestamp))
+    except ValueError:
+        return None
+    return timestamp.strftime('%Y%m%d%H%M%S')
+
+
+def get_version_tuple(version):
+    """
+    Return a tuple of version numbers (e.g. (1, 2, 3)) from the version
+    string (e.g. '1.2.3').
+    """
+    loose_version = LooseVersion(version)
+    version_numbers = []
+    for item in loose_version.version:
+        if not isinstance(item, int):
+            break
+        version_numbers.append(item)
+    return tuple(version_numbers)