Initial commit. Basic models mostly done.

venv/lib/python3.8/site-packages/django/db/models/__init__.py

@@ -0,0 +1,50 @@
+from django.core.exceptions import ObjectDoesNotExist
+from django.db.models import signals
+from django.db.models.aggregates import *  # NOQA
+from django.db.models.aggregates import __all__ as aggregates_all
+from django.db.models.constraints import *  # NOQA
+from django.db.models.constraints import __all__ as constraints_all
+from django.db.models.deletion import (
+    CASCADE, DO_NOTHING, PROTECT, SET, SET_DEFAULT, SET_NULL, ProtectedError,
+)
+from django.db.models.enums import *  # NOQA
+from django.db.models.enums import __all__ as enums_all
+from django.db.models.expressions import (
+    Case, Exists, Expression, ExpressionList, ExpressionWrapper, F, Func,
+    OuterRef, RowRange, Subquery, Value, ValueRange, When, Window, WindowFrame,
+)
+from django.db.models.fields import *  # NOQA
+from django.db.models.fields import __all__ as fields_all
+from django.db.models.fields.files import FileField, ImageField
+from django.db.models.fields.proxy import OrderWrt
+from django.db.models.indexes import *  # NOQA
+from django.db.models.indexes import __all__ as indexes_all
+from django.db.models.lookups import Lookup, Transform
+from django.db.models.manager import Manager
+from django.db.models.query import (
+    Prefetch, Q, QuerySet, prefetch_related_objects,
+)
+from django.db.models.query_utils import FilteredRelation
+
+# Imports that would create circular imports if sorted
+from django.db.models.base import DEFERRED, Model  # isort:skip
+from django.db.models.fields.related import (  # isort:skip
+    ForeignKey, ForeignObject, OneToOneField, ManyToManyField,
+    ManyToOneRel, ManyToManyRel, OneToOneRel,
+)
+
+
+__all__ = aggregates_all + constraints_all + enums_all + fields_all + indexes_all
+__all__ += [
+    'ObjectDoesNotExist', 'signals',
+    'CASCADE', 'DO_NOTHING', 'PROTECT', 'SET', 'SET_DEFAULT', 'SET_NULL',
+    'ProtectedError',
+    'Case', 'Exists', 'Expression', 'ExpressionList', 'ExpressionWrapper', 'F',
+    'Func', 'OuterRef', 'RowRange', 'Subquery', 'Value', 'ValueRange', 'When',
+    'Window', 'WindowFrame',
+    'FileField', 'ImageField', 'OrderWrt', 'Lookup', 'Transform', 'Manager',
+    'Prefetch', 'Q', 'QuerySet', 'prefetch_related_objects', 'DEFERRED', 'Model',
+    'FilteredRelation',
+    'ForeignKey', 'ForeignObject', 'OneToOneField', 'ManyToManyField',
+    'ManyToOneRel', 'ManyToManyRel', 'OneToOneRel',
+]

venv/lib/python3.8/site-packages/django/db/models/aggregates.py

@@ -0,0 +1,157 @@
+"""
+Classes to represent the definitions of aggregate functions.
+"""
+from django.core.exceptions import FieldError
+from django.db.models.expressions import Case, Func, Star, When
+from django.db.models.fields import IntegerField
+from django.db.models.functions.mixins import (
+    FixDurationInputMixin, NumericOutputFieldMixin,
+)
+
+__all__ = [
+    'Aggregate', 'Avg', 'Count', 'Max', 'Min', 'StdDev', 'Sum', 'Variance',
+]
+
+
+class Aggregate(Func):
+    template = '%(function)s(%(distinct)s%(expressions)s)'
+    contains_aggregate = True
+    name = None
+    filter_template = '%s FILTER (WHERE %%(filter)s)'
+    window_compatible = True
+    allow_distinct = False
+
+    def __init__(self, *expressions, distinct=False, filter=None, **extra):
+        if distinct and not self.allow_distinct:
+            raise TypeError("%s does not allow distinct." % self.__class__.__name__)
+        self.distinct = distinct
+        self.filter = filter
+        super().__init__(*expressions, **extra)
+
+    def get_source_fields(self):
+        # Don't return the filter expression since it's not a source field.
+        return [e._output_field_or_none for e in super().get_source_expressions()]
+
+    def get_source_expressions(self):
+        source_expressions = super().get_source_expressions()
+        if self.filter:
+            return source_expressions + [self.filter]
+        return source_expressions
+
+    def set_source_expressions(self, exprs):
+        self.filter = self.filter and exprs.pop()
+        return super().set_source_expressions(exprs)
+
+    def resolve_expression(self, query=None, allow_joins=True, reuse=None, summarize=False, for_save=False):
+        # Aggregates are not allowed in UPDATE queries, so ignore for_save
+        c = super().resolve_expression(query, allow_joins, reuse, summarize)
+        c.filter = c.filter and c.filter.resolve_expression(query, allow_joins, reuse, summarize)
+        if not summarize:
+            # Call Aggregate.get_source_expressions() to avoid
+            # returning self.filter and including that in this loop.
+            expressions = super(Aggregate, c).get_source_expressions()
+            for index, expr in enumerate(expressions):
+                if expr.contains_aggregate:
+                    before_resolved = self.get_source_expressions()[index]
+                    name = before_resolved.name if hasattr(before_resolved, 'name') else repr(before_resolved)
+                    raise FieldError("Cannot compute %s('%s'): '%s' is an aggregate" % (c.name, name, name))
+        return c
+
+    @property
+    def default_alias(self):
+        expressions = self.get_source_expressions()
+        if len(expressions) == 1 and hasattr(expressions[0], 'name'):
+            return '%s__%s' % (expressions[0].name, self.name.lower())
+        raise TypeError("Complex expressions require an alias")
+
+    def get_group_by_cols(self, alias=None):
+        return []
+
+    def as_sql(self, compiler, connection, **extra_context):
+        extra_context['distinct'] = 'DISTINCT ' if self.distinct else ''
+        if self.filter:
+            if connection.features.supports_aggregate_filter_clause:
+                filter_sql, filter_params = self.filter.as_sql(compiler, connection)
+                template = self.filter_template % extra_context.get('template', self.template)
+                sql, params = super().as_sql(
+                    compiler, connection, template=template, filter=filter_sql,
+                    **extra_context
+                )
+                return sql, params + filter_params
+            else:
+                copy = self.copy()
+                copy.filter = None
+                source_expressions = copy.get_source_expressions()
+                condition = When(self.filter, then=source_expressions[0])
+                copy.set_source_expressions([Case(condition)] + source_expressions[1:])
+                return super(Aggregate, copy).as_sql(compiler, connection, **extra_context)
+        return super().as_sql(compiler, connection, **extra_context)
+
+    def _get_repr_options(self):
+        options = super()._get_repr_options()
+        if self.distinct:
+            options['distinct'] = self.distinct
+        if self.filter:
+            options['filter'] = self.filter
+        return options
+
+
+class Avg(FixDurationInputMixin, NumericOutputFieldMixin, Aggregate):
+    function = 'AVG'
+    name = 'Avg'
+    allow_distinct = True
+
+
+class Count(Aggregate):
+    function = 'COUNT'
+    name = 'Count'
+    output_field = IntegerField()
+    allow_distinct = True
+
+    def __init__(self, expression, filter=None, **extra):
+        if expression == '*':
+            expression = Star()
+        if isinstance(expression, Star) and filter is not None:
+            raise ValueError('Star cannot be used with filter. Please specify a field.')
+        super().__init__(expression, filter=filter, **extra)
+
+    def convert_value(self, value, expression, connection):
+        return 0 if value is None else value
+
+
+class Max(Aggregate):
+    function = 'MAX'
+    name = 'Max'
+
+
+class Min(Aggregate):
+    function = 'MIN'
+    name = 'Min'
+
+
+class StdDev(NumericOutputFieldMixin, Aggregate):
+    name = 'StdDev'
+
+    def __init__(self, expression, sample=False, **extra):
+        self.function = 'STDDEV_SAMP' if sample else 'STDDEV_POP'
+        super().__init__(expression, **extra)
+
+    def _get_repr_options(self):
+        return {**super()._get_repr_options(), 'sample': self.function == 'STDDEV_SAMP'}
+
+
+class Sum(FixDurationInputMixin, Aggregate):
+    function = 'SUM'
+    name = 'Sum'
+    allow_distinct = True
+
+
+class Variance(NumericOutputFieldMixin, Aggregate):
+    name = 'Variance'
+
+    def __init__(self, expression, sample=False, **extra):
+        self.function = 'VAR_SAMP' if sample else 'VAR_POP'
+        super().__init__(expression, **extra)
+
+    def _get_repr_options(self):
+        return {**super()._get_repr_options(), 'sample': self.function == 'VAR_SAMP'}

venv/lib/python3.8/site-packages/django/db/models/constants.py

@@ -0,0 +1,6 @@
+"""
+Constants used across the ORM in general.
+"""
+
+# Separator used to split filter strings apart.
+LOOKUP_SEP = '__'

venv/lib/python3.8/site-packages/django/db/models/constraints.py

@@ -0,0 +1,121 @@
+from django.db.models.query_utils import Q
+from django.db.models.sql.query import Query
+
+__all__ = ['CheckConstraint', 'UniqueConstraint']
+
+
+class BaseConstraint:
+    def __init__(self, name):
+        self.name = name
+
+    def constraint_sql(self, model, schema_editor):
+        raise NotImplementedError('This method must be implemented by a subclass.')
+
+    def create_sql(self, model, schema_editor):
+        raise NotImplementedError('This method must be implemented by a subclass.')
+
+    def remove_sql(self, model, schema_editor):
+        raise NotImplementedError('This method must be implemented by a subclass.')
+
+    def deconstruct(self):
+        path = '%s.%s' % (self.__class__.__module__, self.__class__.__name__)
+        path = path.replace('django.db.models.constraints', 'django.db.models')
+        return (path, (), {'name': self.name})
+
+    def clone(self):
+        _, args, kwargs = self.deconstruct()
+        return self.__class__(*args, **kwargs)
+
+
+class CheckConstraint(BaseConstraint):
+    def __init__(self, *, check, name):
+        self.check = check
+        super().__init__(name)
+
+    def _get_check_sql(self, model, schema_editor):
+        query = Query(model=model)
+        where = query.build_where(self.check)
+        compiler = query.get_compiler(connection=schema_editor.connection)
+        sql, params = where.as_sql(compiler, schema_editor.connection)
+        return sql % tuple(schema_editor.quote_value(p) for p in params)
+
+    def constraint_sql(self, model, schema_editor):
+        check = self._get_check_sql(model, schema_editor)
+        return schema_editor._check_sql(self.name, check)
+
+    def create_sql(self, model, schema_editor):
+        check = self._get_check_sql(model, schema_editor)
+        return schema_editor._create_check_sql(model, self.name, check)
+
+    def remove_sql(self, model, schema_editor):
+        return schema_editor._delete_check_sql(model, self.name)
+
+    def __repr__(self):
+        return "<%s: check='%s' name=%r>" % (self.__class__.__name__, self.check, self.name)
+
+    def __eq__(self, other):
+        return (
+            isinstance(other, CheckConstraint) and
+            self.name == other.name and
+            self.check == other.check
+        )
+
+    def deconstruct(self):
+        path, args, kwargs = super().deconstruct()
+        kwargs['check'] = self.check
+        return path, args, kwargs
+
+
+class UniqueConstraint(BaseConstraint):
+    def __init__(self, *, fields, name, condition=None):
+        if not fields:
+            raise ValueError('At least one field is required to define a unique constraint.')
+        if not isinstance(condition, (type(None), Q)):
+            raise ValueError('UniqueConstraint.condition must be a Q instance.')
+        self.fields = tuple(fields)
+        self.condition = condition
+        super().__init__(name)
+
+    def _get_condition_sql(self, model, schema_editor):
+        if self.condition is None:
+            return None
+        query = Query(model=model)
+        where = query.build_where(self.condition)
+        compiler = query.get_compiler(connection=schema_editor.connection)
+        sql, params = where.as_sql(compiler, schema_editor.connection)
+        return sql % tuple(schema_editor.quote_value(p) for p in params)
+
+    def constraint_sql(self, model, schema_editor):
+        fields = [model._meta.get_field(field_name).column for field_name in self.fields]
+        condition = self._get_condition_sql(model, schema_editor)
+        return schema_editor._unique_sql(model, fields, self.name, condition=condition)
+
+    def create_sql(self, model, schema_editor):
+        fields = [model._meta.get_field(field_name).column for field_name in self.fields]
+        condition = self._get_condition_sql(model, schema_editor)
+        return schema_editor._create_unique_sql(model, fields, self.name, condition=condition)
+
+    def remove_sql(self, model, schema_editor):
+        condition = self._get_condition_sql(model, schema_editor)
+        return schema_editor._delete_unique_sql(model, self.name, condition=condition)
+
+    def __repr__(self):
+        return '<%s: fields=%r name=%r%s>' % (
+            self.__class__.__name__, self.fields, self.name,
+            '' if self.condition is None else ' condition=%s' % self.condition,
+        )
+
+    def __eq__(self, other):
+        return (
+            isinstance(other, UniqueConstraint) and
+            self.name == other.name and
+            self.fields == other.fields and
+            self.condition == other.condition
+        )
+
+    def deconstruct(self):
+        path, args, kwargs = super().deconstruct()
+        kwargs['fields'] = self.fields
+        if self.condition:
+            kwargs['condition'] = self.condition
+        return path, args, kwargs

venv/lib/python3.8/site-packages/django/db/models/deletion.py

@@ -0,0 +1,349 @@
+from collections import Counter
+from itertools import chain
+from operator import attrgetter
+
+from django.db import IntegrityError, connections, transaction
+from django.db.models import signals, sql
+
+
+class ProtectedError(IntegrityError):
+    def __init__(self, msg, protected_objects):
+        self.protected_objects = protected_objects
+        super().__init__(msg, protected_objects)
+
+
+def CASCADE(collector, field, sub_objs, using):
+    collector.collect(sub_objs, source=field.remote_field.model,
+                      source_attr=field.name, nullable=field.null)
+    if field.null and not connections[using].features.can_defer_constraint_checks:
+        collector.add_field_update(field, None, sub_objs)
+
+
+def PROTECT(collector, field, sub_objs, using):
+    raise ProtectedError(
+        "Cannot delete some instances of model '%s' because they are "
+        "referenced through a protected foreign key: '%s.%s'" % (
+            field.remote_field.model.__name__, sub_objs[0].__class__.__name__, field.name
+        ),
+        sub_objs
+    )
+
+
+def SET(value):
+    if callable(value):
+        def set_on_delete(collector, field, sub_objs, using):
+            collector.add_field_update(field, value(), sub_objs)
+    else:
+        def set_on_delete(collector, field, sub_objs, using):
+            collector.add_field_update(field, value, sub_objs)
+    set_on_delete.deconstruct = lambda: ('django.db.models.SET', (value,), {})
+    return set_on_delete
+
+
+def SET_NULL(collector, field, sub_objs, using):
+    collector.add_field_update(field, None, sub_objs)
+
+
+def SET_DEFAULT(collector, field, sub_objs, using):
+    collector.add_field_update(field, field.get_default(), sub_objs)
+
+
+def DO_NOTHING(collector, field, sub_objs, using):
+    pass
+
+
+def get_candidate_relations_to_delete(opts):
+    # The candidate relations are the ones that come from N-1 and 1-1 relations.
+    # N-N  (i.e., many-to-many) relations aren't candidates for deletion.
+    return (
+        f for f in opts.get_fields(include_hidden=True)
+        if f.auto_created and not f.concrete and (f.one_to_one or f.one_to_many)
+    )
+
+
+class Collector:
+    def __init__(self, using):
+        self.using = using
+        # Initially, {model: {instances}}, later values become lists.
+        self.data = {}
+        self.field_updates = {}  # {model: {(field, value): {instances}}}
+        # fast_deletes is a list of queryset-likes that can be deleted without
+        # fetching the objects into memory.
+        self.fast_deletes = []
+
+        # Tracks deletion-order dependency for databases without transactions
+        # or ability to defer constraint checks. Only concrete model classes
+        # should be included, as the dependencies exist only between actual
+        # database tables; proxy models are represented here by their concrete
+        # parent.
+        self.dependencies = {}  # {model: {models}}
+
+    def add(self, objs, source=None, nullable=False, reverse_dependency=False):
+        """
+        Add 'objs' to the collection of objects to be deleted.  If the call is
+        the result of a cascade, 'source' should be the model that caused it,
+        and 'nullable' should be set to True if the relation can be null.
+
+        Return a list of all objects that were not already collected.
+        """
+        if not objs:
+            return []
+        new_objs = []
+        model = objs[0].__class__
+        instances = self.data.setdefault(model, set())
+        for obj in objs:
+            if obj not in instances:
+                new_objs.append(obj)
+        instances.update(new_objs)
+        # Nullable relationships can be ignored -- they are nulled out before
+        # deleting, and therefore do not affect the order in which objects have
+        # to be deleted.
+        if source is not None and not nullable:
+            if reverse_dependency:
+                source, model = model, source
+            self.dependencies.setdefault(
+                source._meta.concrete_model, set()).add(model._meta.concrete_model)
+        return new_objs
+
+    def add_field_update(self, field, value, objs):
+        """
+        Schedule a field update. 'objs' must be a homogeneous iterable
+        collection of model instances (e.g. a QuerySet).
+        """
+        if not objs:
+            return
+        model = objs[0].__class__
+        self.field_updates.setdefault(
+            model, {}).setdefault(
+            (field, value), set()).update(objs)
+
+    def _has_signal_listeners(self, model):
+        return (
+            signals.pre_delete.has_listeners(model) or
+            signals.post_delete.has_listeners(model)
+        )
+
+    def can_fast_delete(self, objs, from_field=None):
+        """
+        Determine if the objects in the given queryset-like or single object
+        can be fast-deleted. This can be done if there are no cascades, no
+        parents and no signal listeners for the object class.
+
+        The 'from_field' tells where we are coming from - we need this to
+        determine if the objects are in fact to be deleted. Allow also
+        skipping parent -> child -> parent chain preventing fast delete of
+        the child.
+        """
+        if from_field and from_field.remote_field.on_delete is not CASCADE:
+            return False
+        if hasattr(objs, '_meta'):
+            model = type(objs)
+        elif hasattr(objs, 'model') and hasattr(objs, '_raw_delete'):
+            model = objs.model
+        else:
+            return False
+        if self._has_signal_listeners(model):
+            return False
+        # The use of from_field comes from the need to avoid cascade back to
+        # parent when parent delete is cascading to child.
+        opts = model._meta
+        return (
+            all(link == from_field for link in opts.concrete_model._meta.parents.values()) and
+            # Foreign keys pointing to this model.
+            all(
+                related.field.remote_field.on_delete is DO_NOTHING
+                for related in get_candidate_relations_to_delete(opts)
+            ) and (
+                # Something like generic foreign key.
+                not any(hasattr(field, 'bulk_related_objects') for field in opts.private_fields)
+            )
+        )
+
+    def get_del_batches(self, objs, field):
+        """
+        Return the objs in suitably sized batches for the used connection.
+        """
+        conn_batch_size = max(
+            connections[self.using].ops.bulk_batch_size([field.name], objs), 1)
+        if len(objs) > conn_batch_size:
+            return [objs[i:i + conn_batch_size]
+                    for i in range(0, len(objs), conn_batch_size)]
+        else:
+            return [objs]
+
+    def collect(self, objs, source=None, nullable=False, collect_related=True,
+                source_attr=None, reverse_dependency=False, keep_parents=False):
+        """
+        Add 'objs' to the collection of objects to be deleted as well as all
+        parent instances.  'objs' must be a homogeneous iterable collection of
+        model instances (e.g. a QuerySet).  If 'collect_related' is True,
+        related objects will be handled by their respective on_delete handler.
+
+        If the call is the result of a cascade, 'source' should be the model
+        that caused it and 'nullable' should be set to True, if the relation
+        can be null.
+
+        If 'reverse_dependency' is True, 'source' will be deleted before the
+        current model, rather than after. (Needed for cascading to parent
+        models, the one case in which the cascade follows the forwards
+        direction of an FK rather than the reverse direction.)
+
+        If 'keep_parents' is True, data of parent model's will be not deleted.
+        """
+        if self.can_fast_delete(objs):
+            self.fast_deletes.append(objs)
+            return
+        new_objs = self.add(objs, source, nullable,
+                            reverse_dependency=reverse_dependency)
+        if not new_objs:
+            return
+
+        model = new_objs[0].__class__
+
+        if not keep_parents:
+            # Recursively collect concrete model's parent models, but not their
+            # related objects. These will be found by meta.get_fields()
+            concrete_model = model._meta.concrete_model
+            for ptr in concrete_model._meta.parents.values():
+                if ptr:
+                    parent_objs = [getattr(obj, ptr.name) for obj in new_objs]
+                    self.collect(parent_objs, source=model,
+                                 source_attr=ptr.remote_field.related_name,
+                                 collect_related=False,
+                                 reverse_dependency=True)
+        if collect_related:
+            if keep_parents:
+                parents = set(model._meta.get_parent_list())
+            for related in get_candidate_relations_to_delete(model._meta):
+                # Preserve parent reverse relationships if keep_parents=True.
+                if keep_parents and related.model in parents:
+                    continue
+                field = related.field
+                if field.remote_field.on_delete == DO_NOTHING:
+                    continue
+                batches = self.get_del_batches(new_objs, field)
+                for batch in batches:
+                    sub_objs = self.related_objects(related, batch)
+                    if self.can_fast_delete(sub_objs, from_field=field):
+                        self.fast_deletes.append(sub_objs)
+                    else:
+                        related_model = related.related_model
+                        # Non-referenced fields can be deferred if no signal
+                        # receivers are connected for the related model as
+                        # they'll never be exposed to the user. Skip field
+                        # deferring when some relationships are select_related
+                        # as interactions between both features are hard to
+                        # get right. This should only happen in the rare
+                        # cases where .related_objects is overridden anyway.
+                        if not (sub_objs.query.select_related or self._has_signal_listeners(related_model)):
+                            referenced_fields = set(chain.from_iterable(
+                                (rf.attname for rf in rel.field.foreign_related_fields)
+                                for rel in get_candidate_relations_to_delete(related_model._meta)
+                            ))
+                            sub_objs = sub_objs.only(*tuple(referenced_fields))
+                        if sub_objs:
+                            field.remote_field.on_delete(self, field, sub_objs, self.using)
+            for field in model._meta.private_fields:
+                if hasattr(field, 'bulk_related_objects'):
+                    # It's something like generic foreign key.
+                    sub_objs = field.bulk_related_objects(new_objs, self.using)
+                    self.collect(sub_objs, source=model, nullable=True)
+
+    def related_objects(self, related, objs):
+        """
+        Get a QuerySet of objects related to `objs` via the relation `related`.
+        """
+        return related.related_model._base_manager.using(self.using).filter(
+            **{"%s__in" % related.field.name: objs}
+        )
+
+    def instances_with_model(self):
+        for model, instances in self.data.items():
+            for obj in instances:
+                yield model, obj
+
+    def sort(self):
+        sorted_models = []
+        concrete_models = set()
+        models = list(self.data)
+        while len(sorted_models) < len(models):
+            found = False
+            for model in models:
+                if model in sorted_models:
+                    continue
+                dependencies = self.dependencies.get(model._meta.concrete_model)
+                if not (dependencies and dependencies.difference(concrete_models)):
+                    sorted_models.append(model)
+                    concrete_models.add(model._meta.concrete_model)
+                    found = True
+            if not found:
+                return
+        self.data = {model: self.data[model] for model in sorted_models}
+
+    def delete(self):
+        # sort instance collections
+        for model, instances in self.data.items():
+            self.data[model] = sorted(instances, key=attrgetter("pk"))
+
+        # if possible, bring the models in an order suitable for databases that
+        # don't support transactions or cannot defer constraint checks until the
+        # end of a transaction.
+        self.sort()
+        # number of objects deleted for each model label
+        deleted_counter = Counter()
+
+        # Optimize for the case with a single obj and no dependencies
+        if len(self.data) == 1 and len(instances) == 1:
+            instance = list(instances)[0]
+            if self.can_fast_delete(instance):
+                with transaction.mark_for_rollback_on_error():
+                    count = sql.DeleteQuery(model).delete_batch([instance.pk], self.using)
+                setattr(instance, model._meta.pk.attname, None)
+                return count, {model._meta.label: count}
+
+        with transaction.atomic(using=self.using, savepoint=False):
+            # send pre_delete signals
+            for model, obj in self.instances_with_model():
+                if not model._meta.auto_created:
+                    signals.pre_delete.send(
+                        sender=model, instance=obj, using=self.using
+                    )
+
+            # fast deletes
+            for qs in self.fast_deletes:
+                count = qs._raw_delete(using=self.using)
+                deleted_counter[qs.model._meta.label] += count
+
+            # update fields
+            for model, instances_for_fieldvalues in self.field_updates.items():
+                for (field, value), instances in instances_for_fieldvalues.items():
+                    query = sql.UpdateQuery(model)
+                    query.update_batch([obj.pk for obj in instances],
+                                       {field.name: value}, self.using)
+
+            # reverse instance collections
+            for instances in self.data.values():
+                instances.reverse()
+
+            # delete instances
+            for model, instances in self.data.items():
+                query = sql.DeleteQuery(model)
+                pk_list = [obj.pk for obj in instances]
+                count = query.delete_batch(pk_list, self.using)
+                deleted_counter[model._meta.label] += count
+
+                if not model._meta.auto_created:
+                    for obj in instances:
+                        signals.post_delete.send(
+                            sender=model, instance=obj, using=self.using
+                        )
+
+        # update collected instances
+        for instances_for_fieldvalues in self.field_updates.values():
+            for (field, value), instances in instances_for_fieldvalues.items():
+                for obj in instances:
+                    setattr(obj, field.attname, value)
+        for model, instances in self.data.items():
+            for instance in instances:
+                setattr(instance, model._meta.pk.attname, None)
+        return sum(deleted_counter.values()), dict(deleted_counter)

venv/lib/python3.8/site-packages/django/db/models/enums.py

@@ -0,0 +1,82 @@
+import enum
+
+from django.utils.functional import Promise
+
+__all__ = ['Choices', 'IntegerChoices', 'TextChoices']
+
+
+class ChoicesMeta(enum.EnumMeta):
+    """A metaclass for creating a enum choices."""
+
+    def __new__(metacls, classname, bases, classdict):
+        labels = []
+        for key in classdict._member_names:
+            value = classdict[key]
+            if (
+                isinstance(value, (list, tuple)) and
+                len(value) > 1 and
+                isinstance(value[-1], (Promise, str))
+            ):
+                *value, label = value
+                value = tuple(value)
+            else:
+                label = key.replace('_', ' ').title()
+            labels.append(label)
+            # Use dict.__setitem__() to suppress defenses against double
+            # assignment in enum's classdict.
+            dict.__setitem__(classdict, key, value)
+        cls = super().__new__(metacls, classname, bases, classdict)
+        cls._value2label_map_ = dict(zip(cls._value2member_map_, labels))
+        # Add a label property to instances of enum which uses the enum member
+        # that is passed in as "self" as the value to use when looking up the
+        # label in the choices.
+        cls.label = property(lambda self: cls._value2label_map_.get(self.value))
+        cls.do_not_call_in_templates = True
+        return enum.unique(cls)
+
+    def __contains__(cls, member):
+        if not isinstance(member, enum.Enum):
+            # Allow non-enums to match against member values.
+            return member in {x.value for x in cls}
+        return super().__contains__(member)
+
+    @property
+    def names(cls):
+        empty = ['__empty__'] if hasattr(cls, '__empty__') else []
+        return empty + [member.name for member in cls]
+
+    @property
+    def choices(cls):
+        empty = [(None, cls.__empty__)] if hasattr(cls, '__empty__') else []
+        return empty + [(member.value, member.label) for member in cls]
+
+    @property
+    def labels(cls):
+        return [label for _, label in cls.choices]
+
+    @property
+    def values(cls):
+        return [value for value, _ in cls.choices]
+
+
+class Choices(enum.Enum, metaclass=ChoicesMeta):
+    """Class for creating enumerated choices."""
+
+    def __str__(self):
+        """
+        Use value when cast to str, so that Choices set as model instance
+        attributes are rendered as expected in templates and similar contexts.
+        """
+        return str(self.value)
+
+
+class IntegerChoices(int, Choices):
+    """Class for creating enumerated integer choices."""
+    pass
+
+
+class TextChoices(str, Choices):
+    """Class for creating enumerated string choices."""
+
+    def _generate_next_value_(name, start, count, last_values):
+        return name

venv/lib/python3.8/site-packages/django/db/models/fields/files.py

@@ -0,0 +1,466 @@
+import datetime
+import posixpath
+
+from django import forms
+from django.core import checks
+from django.core.files.base import File
+from django.core.files.images import ImageFile
+from django.core.files.storage import default_storage
+from django.db.models import signals
+from django.db.models.fields import Field
+from django.utils.translation import gettext_lazy as _
+
+
+class FieldFile(File):
+    def __init__(self, instance, field, name):
+        super().__init__(None, name)
+        self.instance = instance
+        self.field = field
+        self.storage = field.storage
+        self._committed = True
+
+    def __eq__(self, other):
+        # Older code may be expecting FileField values to be simple strings.
+        # By overriding the == operator, it can remain backwards compatibility.
+        if hasattr(other, 'name'):
+            return self.name == other.name
+        return self.name == other
+
+    def __hash__(self):
+        return hash(self.name)
+
+    # The standard File contains most of the necessary properties, but
+    # FieldFiles can be instantiated without a name, so that needs to
+    # be checked for here.
+
+    def _require_file(self):
+        if not self:
+            raise ValueError("The '%s' attribute has no file associated with it." % self.field.name)
+
+    def _get_file(self):
+        self._require_file()
+        if getattr(self, '_file', None) is None:
+            self._file = self.storage.open(self.name, 'rb')
+        return self._file
+
+    def _set_file(self, file):
+        self._file = file
+
+    def _del_file(self):
+        del self._file
+
+    file = property(_get_file, _set_file, _del_file)
+
+    @property
+    def path(self):
+        self._require_file()
+        return self.storage.path(self.name)
+
+    @property
+    def url(self):
+        self._require_file()
+        return self.storage.url(self.name)
+
+    @property
+    def size(self):
+        self._require_file()
+        if not self._committed:
+            return self.file.size
+        return self.storage.size(self.name)
+
+    def open(self, mode='rb'):
+        self._require_file()
+        if getattr(self, '_file', None) is None:
+            self.file = self.storage.open(self.name, mode)
+        else:
+            self.file.open(mode)
+        return self
+    # open() doesn't alter the file's contents, but it does reset the pointer
+    open.alters_data = True
+
+    # In addition to the standard File API, FieldFiles have extra methods
+    # to further manipulate the underlying file, as well as update the
+    # associated model instance.
+
+    def save(self, name, content, save=True):
+        name = self.field.generate_filename(self.instance, name)
+        self.name = self.storage.save(name, content, max_length=self.field.max_length)
+        setattr(self.instance, self.field.name, self.name)
+        self._committed = True
+
+        # Save the object because it has changed, unless save is False
+        if save:
+            self.instance.save()
+    save.alters_data = True
+
+    def delete(self, save=True):
+        if not self:
+            return
+        # Only close the file if it's already open, which we know by the
+        # presence of self._file
+        if hasattr(self, '_file'):
+            self.close()
+            del self.file
+
+        self.storage.delete(self.name)
+
+        self.name = None
+        setattr(self.instance, self.field.name, self.name)
+        self._committed = False
+
+        if save:
+            self.instance.save()
+    delete.alters_data = True
+
+    @property
+    def closed(self):
+        file = getattr(self, '_file', None)
+        return file is None or file.closed
+
+    def close(self):
+        file = getattr(self, '_file', None)
+        if file is not None:
+            file.close()
+
+    def __getstate__(self):
+        # FieldFile needs access to its associated model field and an instance
+        # it's attached to in order to work properly, but the only necessary
+        # data to be pickled is the file's name itself. Everything else will
+        # be restored later, by FileDescriptor below.
+        return {'name': self.name, 'closed': False, '_committed': True, '_file': None}
+
+
+class FileDescriptor:
+    """
+    The descriptor for the file attribute on the model instance. Return a
+    FieldFile when accessed so you can write code like::
+
+        >>> from myapp.models import MyModel
+        >>> instance = MyModel.objects.get(pk=1)
+        >>> instance.file.size
+
+    Assign a file object on assignment so you can do::
+
+        >>> with open('/path/to/hello.world') as f:
+        ...     instance.file = File(f)
+    """
+    def __init__(self, field):
+        self.field = field
+
+    def __get__(self, instance, cls=None):
+        if instance is None:
+            return self
+
+        # This is slightly complicated, so worth an explanation.
+        # instance.file`needs to ultimately return some instance of `File`,
+        # probably a subclass. Additionally, this returned object needs to have
+        # the FieldFile API so that users can easily do things like
+        # instance.file.path and have that delegated to the file storage engine.
+        # Easy enough if we're strict about assignment in __set__, but if you
+        # peek below you can see that we're not. So depending on the current
+        # value of the field we have to dynamically construct some sort of
+        # "thing" to return.
+
+        # The instance dict contains whatever was originally assigned
+        # in __set__.
+        if self.field.name in instance.__dict__:
+            file = instance.__dict__[self.field.name]
+        else:
+            instance.refresh_from_db(fields=[self.field.name])
+            file = getattr(instance, self.field.name)
+
+        # If this value is a string (instance.file = "path/to/file") or None
+        # then we simply wrap it with the appropriate attribute class according
+        # to the file field. [This is FieldFile for FileFields and
+        # ImageFieldFile for ImageFields; it's also conceivable that user
+        # subclasses might also want to subclass the attribute class]. This
+        # object understands how to convert a path to a file, and also how to
+        # handle None.
+        if isinstance(file, str) or file is None:
+            attr = self.field.attr_class(instance, self.field, file)
+            instance.__dict__[self.field.name] = attr
+
+        # Other types of files may be assigned as well, but they need to have
+        # the FieldFile interface added to them. Thus, we wrap any other type of
+        # File inside a FieldFile (well, the field's attr_class, which is
+        # usually FieldFile).
+        elif isinstance(file, File) and not isinstance(file, FieldFile):
+            file_copy = self.field.attr_class(instance, self.field, file.name)
+            file_copy.file = file
+            file_copy._committed = False
+            instance.__dict__[self.field.name] = file_copy
+
+        # Finally, because of the (some would say boneheaded) way pickle works,
+        # the underlying FieldFile might not actually itself have an associated
+        # file. So we need to reset the details of the FieldFile in those cases.
+        elif isinstance(file, FieldFile) and not hasattr(file, 'field'):
+            file.instance = instance
+            file.field = self.field
+            file.storage = self.field.storage
+
+        # Make sure that the instance is correct.
+        elif isinstance(file, FieldFile) and instance is not file.instance:
+            file.instance = instance
+
+        # That was fun, wasn't it?
+        return instance.__dict__[self.field.name]
+
+    def __set__(self, instance, value):
+        instance.__dict__[self.field.name] = value
+
+
+class FileField(Field):
+
+    # The class to wrap instance attributes in. Accessing the file object off
+    # the instance will always return an instance of attr_class.
+    attr_class = FieldFile
+
+    # The descriptor to use for accessing the attribute off of the class.
+    descriptor_class = FileDescriptor
+
+    description = _("File")
+
+    def __init__(self, verbose_name=None, name=None, upload_to='', storage=None, **kwargs):
+        self._primary_key_set_explicitly = 'primary_key' in kwargs
+
+        self.storage = storage or default_storage
+        self.upload_to = upload_to
+
+        kwargs.setdefault('max_length', 100)
+        super().__init__(verbose_name, name, **kwargs)
+
+    def check(self, **kwargs):
+        return [
+            *super().check(**kwargs),
+            *self._check_primary_key(),
+            *self._check_upload_to(),
+        ]
+
+    def _check_primary_key(self):
+        if self._primary_key_set_explicitly:
+            return [
+                checks.Error(
+                    "'primary_key' is not a valid argument for a %s." % self.__class__.__name__,
+                    obj=self,
+                    id='fields.E201',
+                )
+            ]
+        else:
+            return []
+
+    def _check_upload_to(self):
+        if isinstance(self.upload_to, str) and self.upload_to.startswith('/'):
+            return [
+                checks.Error(
+                    "%s's 'upload_to' argument must be a relative path, not an "
+                    "absolute path." % self.__class__.__name__,
+                    obj=self,
+                    id='fields.E202',
+                    hint='Remove the leading slash.',
+                )
+            ]
+        else:
+            return []
+
+    def deconstruct(self):
+        name, path, args, kwargs = super().deconstruct()
+        if kwargs.get("max_length") == 100:
+            del kwargs["max_length"]
+        kwargs['upload_to'] = self.upload_to
+        if self.storage is not default_storage:
+            kwargs['storage'] = self.storage
+        return name, path, args, kwargs
+
+    def get_internal_type(self):
+        return "FileField"
+
+    def get_prep_value(self, value):
+        value = super().get_prep_value(value)
+        # Need to convert File objects provided via a form to string for database insertion
+        if value is None:
+            return None
+        return str(value)
+
+    def pre_save(self, model_instance, add):
+        file = super().pre_save(model_instance, add)
+        if file and not file._committed:
+            # Commit the file to storage prior to saving the model
+            file.save(file.name, file.file, save=False)
+        return file
+
+    def contribute_to_class(self, cls, name, **kwargs):
+        super().contribute_to_class(cls, name, **kwargs)
+        setattr(cls, self.name, self.descriptor_class(self))
+
+    def generate_filename(self, instance, filename):
+        """
+        Apply (if callable) or prepend (if a string) upload_to to the filename,
+        then delegate further processing of the name to the storage backend.
+        Until the storage layer, all file paths are expected to be Unix style
+        (with forward slashes).
+        """
+        if callable(self.upload_to):
+            filename = self.upload_to(instance, filename)
+        else:
+            dirname = datetime.datetime.now().strftime(str(self.upload_to))
+            filename = posixpath.join(dirname, filename)
+        return self.storage.generate_filename(filename)
+
+    def save_form_data(self, instance, data):
+        # Important: None means "no change", other false value means "clear"
+        # This subtle distinction (rather than a more explicit marker) is
+        # needed because we need to consume values that are also sane for a
+        # regular (non Model-) Form to find in its cleaned_data dictionary.
+        if data is not None:
+            # This value will be converted to str and stored in the
+            # database, so leaving False as-is is not acceptable.
+            setattr(instance, self.name, data or '')
+
+    def formfield(self, **kwargs):
+        return super().formfield(**{
+            'form_class': forms.FileField,
+            'max_length': self.max_length,
+            **kwargs,
+        })
+
+
+class ImageFileDescriptor(FileDescriptor):
+    """
+    Just like the FileDescriptor, but for ImageFields. The only difference is
+    assigning the width/height to the width_field/height_field, if appropriate.
+    """
+    def __set__(self, instance, value):
+        previous_file = instance.__dict__.get(self.field.name)
+        super().__set__(instance, value)
+
+        # To prevent recalculating image dimensions when we are instantiating
+        # an object from the database (bug #11084), only update dimensions if
+        # the field had a value before this assignment.  Since the default
+        # value for FileField subclasses is an instance of field.attr_class,
+        # previous_file will only be None when we are called from
+        # Model.__init__().  The ImageField.update_dimension_fields method
+        # hooked up to the post_init signal handles the Model.__init__() cases.
+        # Assignment happening outside of Model.__init__() will trigger the
+        # update right here.
+        if previous_file is not None:
+            self.field.update_dimension_fields(instance, force=True)
+
+
+class ImageFieldFile(ImageFile, FieldFile):
+    def delete(self, save=True):
+        # Clear the image dimensions cache
+        if hasattr(self, '_dimensions_cache'):
+            del self._dimensions_cache
+        super().delete(save)
+
+
+class ImageField(FileField):
+    attr_class = ImageFieldFile
+    descriptor_class = ImageFileDescriptor
+    description = _("Image")
+
+    def __init__(self, verbose_name=None, name=None, width_field=None, height_field=None, **kwargs):
+        self.width_field, self.height_field = width_field, height_field
+        super().__init__(verbose_name, name, **kwargs)
+
+    def check(self, **kwargs):
+        return [
+            *super().check(**kwargs),
+            *self._check_image_library_installed(),
+        ]
+
+    def _check_image_library_installed(self):
+        try:
+            from PIL import Image  # NOQA
+        except ImportError:
+            return [
+                checks.Error(
+                    'Cannot use ImageField because Pillow is not installed.',
+                    hint=('Get Pillow at https://pypi.org/project/Pillow/ '
+                          'or run command "python -m pip install Pillow".'),
+                    obj=self,
+                    id='fields.E210',
+                )
+            ]
+        else:
+            return []
+
+    def deconstruct(self):
+        name, path, args, kwargs = super().deconstruct()
+        if self.width_field:
+            kwargs['width_field'] = self.width_field
+        if self.height_field:
+            kwargs['height_field'] = self.height_field
+        return name, path, args, kwargs
+
+    def contribute_to_class(self, cls, name, **kwargs):
+        super().contribute_to_class(cls, name, **kwargs)
+        # Attach update_dimension_fields so that dimension fields declared
+        # after their corresponding image field don't stay cleared by
+        # Model.__init__, see bug #11196.
+        # Only run post-initialization dimension update on non-abstract models
+        if not cls._meta.abstract:
+            signals.post_init.connect(self.update_dimension_fields, sender=cls)
+
+    def update_dimension_fields(self, instance, force=False, *args, **kwargs):
+        """
+        Update field's width and height fields, if defined.
+
+        This method is hooked up to model's post_init signal to update
+        dimensions after instantiating a model instance.  However, dimensions
+        won't be updated if the dimensions fields are already populated.  This
+        avoids unnecessary recalculation when loading an object from the
+        database.
+
+        Dimensions can be forced to update with force=True, which is how
+        ImageFileDescriptor.__set__ calls this method.
+        """
+        # Nothing to update if the field doesn't have dimension fields or if
+        # the field is deferred.
+        has_dimension_fields = self.width_field or self.height_field
+        if not has_dimension_fields or self.attname not in instance.__dict__:
+            return
+
+        # getattr will call the ImageFileDescriptor's __get__ method, which
+        # coerces the assigned value into an instance of self.attr_class
+        # (ImageFieldFile in this case).
+        file = getattr(instance, self.attname)
+
+        # Nothing to update if we have no file and not being forced to update.
+        if not file and not force:
+            return
+
+        dimension_fields_filled = not(
+            (self.width_field and not getattr(instance, self.width_field)) or
+            (self.height_field and not getattr(instance, self.height_field))
+        )
+        # When both dimension fields have values, we are most likely loading
+        # data from the database or updating an image field that already had
+        # an image stored.  In the first case, we don't want to update the
+        # dimension fields because we are already getting their values from the
+        # database.  In the second case, we do want to update the dimensions
+        # fields and will skip this return because force will be True since we
+        # were called from ImageFileDescriptor.__set__.
+        if dimension_fields_filled and not force:
+            return
+
+        # file should be an instance of ImageFieldFile or should be None.
+        if file:
+            width = file.width
+            height = file.height
+        else:
+            # No file, so clear dimensions fields.
+            width = None
+            height = None
+
+        # Update the width and height fields.
+        if self.width_field:
+            setattr(instance, self.width_field, width)
+        if self.height_field:
+            setattr(instance, self.height_field, height)
+
+    def formfield(self, **kwargs):
+        return super().formfield(**{
+            'form_class': forms.ImageField,
+            **kwargs,
+        })

venv/lib/python3.8/site-packages/django/db/models/fields/mixins.py

@@ -0,0 +1,26 @@
+NOT_PROVIDED = object()
+
+
+class FieldCacheMixin:
+    """Provide an API for working with the model's fields value cache."""
+
+    def get_cache_name(self):
+        raise NotImplementedError
+
+    def get_cached_value(self, instance, default=NOT_PROVIDED):
+        cache_name = self.get_cache_name()
+        try:
+            return instance._state.fields_cache[cache_name]
+        except KeyError:
+            if default is NOT_PROVIDED:
+                raise
+            return default
+
+    def is_cached(self, instance):
+        return self.get_cache_name() in instance._state.fields_cache
+
+    def set_cached_value(self, instance, value):
+        instance._state.fields_cache[self.get_cache_name()] = value
+
+    def delete_cached_value(self, instance):
+        del instance._state.fields_cache[self.get_cache_name()]

venv/lib/python3.8/site-packages/django/db/models/fields/proxy.py

@@ -0,0 +1,18 @@
+"""
+Field-like classes that aren't really fields. It's easier to use objects that
+have the same attributes as fields sometimes (avoids a lot of special casing).
+"""
+
+from django.db.models import fields
+
+
+class OrderWrt(fields.IntegerField):
+    """
+    A proxy for the _order database field that is used when
+    Meta.order_with_respect_to is specified.
+    """
+
+    def __init__(self, *args, **kwargs):
+        kwargs['name'] = '_order'
+        kwargs['editable'] = False
+        super().__init__(*args, **kwargs)

venv/lib/python3.8/site-packages/django/db/models/fields/related_lookups.py

@@ -0,0 +1,154 @@
+from django.db.models.lookups import (
+    Exact, GreaterThan, GreaterThanOrEqual, In, IsNull, LessThan,
+    LessThanOrEqual,
+)
+
+
+class MultiColSource:
+    contains_aggregate = False
+
+    def __init__(self, alias, targets, sources, field):
+        self.targets, self.sources, self.field, self.alias = targets, sources, field, alias
+        self.output_field = self.field
+
+    def __repr__(self):
+        return "{}({}, {})".format(
+            self.__class__.__name__, self.alias, self.field)
+
+    def relabeled_clone(self, relabels):
+        return self.__class__(relabels.get(self.alias, self.alias),
+                              self.targets, self.sources, self.field)
+
+    def get_lookup(self, lookup):
+        return self.output_field.get_lookup(lookup)
+
+
+def get_normalized_value(value, lhs):
+    from django.db.models import Model
+    if isinstance(value, Model):
+        value_list = []
+        sources = lhs.output_field.get_path_info()[-1].target_fields
+        for source in sources:
+            while not isinstance(value, source.model) and source.remote_field:
+                source = source.remote_field.model._meta.get_field(source.remote_field.field_name)
+            try:
+                value_list.append(getattr(value, source.attname))
+            except AttributeError:
+                # A case like Restaurant.objects.filter(place=restaurant_instance),
+                # where place is a OneToOneField and the primary key of Restaurant.
+                return (value.pk,)
+        return tuple(value_list)
+    if not isinstance(value, tuple):
+        return (value,)
+    return value
+
+
+class RelatedIn(In):
+    def get_prep_lookup(self):
+        if not isinstance(self.lhs, MultiColSource) and self.rhs_is_direct_value():
+            # If we get here, we are dealing with single-column relations.
+            self.rhs = [get_normalized_value(val, self.lhs)[0] for val in self.rhs]
+            # We need to run the related field's get_prep_value(). Consider case
+            # ForeignKey to IntegerField given value 'abc'. The ForeignKey itself
+            # doesn't have validation for non-integers, so we must run validation
+            # using the target field.
+            if hasattr(self.lhs.output_field, 'get_path_info'):
+                # Run the target field's get_prep_value. We can safely assume there is
+                # only one as we don't get to the direct value branch otherwise.
+                target_field = self.lhs.output_field.get_path_info()[-1].target_fields[-1]
+                self.rhs = [target_field.get_prep_value(v) for v in self.rhs]
+        return super().get_prep_lookup()
+
+    def as_sql(self, compiler, connection):
+        if isinstance(self.lhs, MultiColSource):
+            # For multicolumn lookups we need to build a multicolumn where clause.
+            # This clause is either a SubqueryConstraint (for values that need to be compiled to
+            # SQL) or an OR-combined list of (col1 = val1 AND col2 = val2 AND ...) clauses.
+            from django.db.models.sql.where import WhereNode, SubqueryConstraint, AND, OR
+
+            root_constraint = WhereNode(connector=OR)
+            if self.rhs_is_direct_value():
+                values = [get_normalized_value(value, self.lhs) for value in self.rhs]
+                for value in values:
+                    value_constraint = WhereNode()
+                    for source, target, val in zip(self.lhs.sources, self.lhs.targets, value):
+                        lookup_class = target.get_lookup('exact')
+                        lookup = lookup_class(target.get_col(self.lhs.alias, source), val)
+                        value_constraint.add(lookup, AND)
+                    root_constraint.add(value_constraint, OR)
+            else:
+                root_constraint.add(
+                    SubqueryConstraint(
+                        self.lhs.alias, [target.column for target in self.lhs.targets],
+                        [source.name for source in self.lhs.sources], self.rhs),
+                    AND)
+            return root_constraint.as_sql(compiler, connection)
+        else:
+            if (not getattr(self.rhs, 'has_select_fields', True) and
+                    not getattr(self.lhs.field.target_field, 'primary_key', False)):
+                self.rhs.clear_select_clause()
+                if (getattr(self.lhs.output_field, 'primary_key', False) and
+                        self.lhs.output_field.model == self.rhs.model):
+                    # A case like Restaurant.objects.filter(place__in=restaurant_qs),
+                    # where place is a OneToOneField and the primary key of
+                    # Restaurant.
+                    target_field = self.lhs.field.name
+                else:
+                    target_field = self.lhs.field.target_field.name
+                self.rhs.add_fields([target_field], True)
+            return super().as_sql(compiler, connection)
+
+
+class RelatedLookupMixin:
+    def get_prep_lookup(self):
+        if not isinstance(self.lhs, MultiColSource) and not hasattr(self.rhs, 'resolve_expression'):
+            # If we get here, we are dealing with single-column relations.
+            self.rhs = get_normalized_value(self.rhs, self.lhs)[0]
+            # We need to run the related field's get_prep_value(). Consider case
+            # ForeignKey to IntegerField given value 'abc'. The ForeignKey itself
+            # doesn't have validation for non-integers, so we must run validation
+            # using the target field.
+            if self.prepare_rhs and hasattr(self.lhs.output_field, 'get_path_info'):
+                # Get the target field. We can safely assume there is only one
+                # as we don't get to the direct value branch otherwise.
+                target_field = self.lhs.output_field.get_path_info()[-1].target_fields[-1]
+                self.rhs = target_field.get_prep_value(self.rhs)
+
+        return super().get_prep_lookup()
+
+    def as_sql(self, compiler, connection):
+        if isinstance(self.lhs, MultiColSource):
+            assert self.rhs_is_direct_value()
+            self.rhs = get_normalized_value(self.rhs, self.lhs)
+            from django.db.models.sql.where import WhereNode, AND
+            root_constraint = WhereNode()
+            for target, source, val in zip(self.lhs.targets, self.lhs.sources, self.rhs):
+                lookup_class = target.get_lookup(self.lookup_name)
+                root_constraint.add(
+                    lookup_class(target.get_col(self.lhs.alias, source), val), AND)
+            return root_constraint.as_sql(compiler, connection)
+        return super().as_sql(compiler, connection)
+
+
+class RelatedExact(RelatedLookupMixin, Exact):
+    pass
+
+
+class RelatedLessThan(RelatedLookupMixin, LessThan):
+    pass
+
+
+class RelatedGreaterThan(RelatedLookupMixin, GreaterThan):
+    pass
+
+
+class RelatedGreaterThanOrEqual(RelatedLookupMixin, GreaterThanOrEqual):
+    pass
+
+
+class RelatedLessThanOrEqual(RelatedLookupMixin, LessThanOrEqual):
+    pass
+
+
+class RelatedIsNull(RelatedLookupMixin, IsNull):
+    pass

venv/lib/python3.8/site-packages/django/db/models/fields/reverse_related.py

@@ -0,0 +1,290 @@
+"""
+"Rel objects" for related fields.
+
+"Rel objects" (for lack of a better name) carry information about the relation
+modeled by a related field and provide some utility functions. They're stored
+in the ``remote_field`` attribute of the field.
+
+They also act as reverse fields for the purposes of the Meta API because
+they're the closest concept currently available.
+"""
+
+from django.core import exceptions
+from django.utils.functional import cached_property
+
+from . import BLANK_CHOICE_DASH
+from .mixins import FieldCacheMixin
+
+
+class ForeignObjectRel(FieldCacheMixin):
+    """
+    Used by ForeignObject to store information about the relation.
+
+    ``_meta.get_fields()`` returns this class to provide access to the field
+    flags for the reverse relation.
+    """
+
+    # Field flags
+    auto_created = True
+    concrete = False
+    editable = False
+    is_relation = True
+
+    # Reverse relations are always nullable (Django can't enforce that a
+    # foreign key on the related model points to this model).
+    null = True
+
+    def __init__(self, field, to, related_name=None, related_query_name=None,
+                 limit_choices_to=None, parent_link=False, on_delete=None):
+        self.field = field
+        self.model = to
+        self.related_name = related_name
+        self.related_query_name = related_query_name
+        self.limit_choices_to = {} if limit_choices_to is None else limit_choices_to
+        self.parent_link = parent_link
+        self.on_delete = on_delete
+
+        self.symmetrical = False
+        self.multiple = True
+
+    # Some of the following cached_properties can't be initialized in
+    # __init__ as the field doesn't have its model yet. Calling these methods
+    # before field.contribute_to_class() has been called will result in
+    # AttributeError
+    @cached_property
+    def hidden(self):
+        return self.is_hidden()
+
+    @cached_property
+    def name(self):
+        return self.field.related_query_name()
+
+    @property
+    def remote_field(self):
+        return self.field
+
+    @property
+    def target_field(self):
+        """
+        When filtering against this relation, return the field on the remote
+        model against which the filtering should happen.
+        """
+        target_fields = self.get_path_info()[-1].target_fields
+        if len(target_fields) > 1:
+            raise exceptions.FieldError("Can't use target_field for multicolumn relations.")
+        return target_fields[0]
+
+    @cached_property
+    def related_model(self):
+        if not self.field.model:
+            raise AttributeError(
+                "This property can't be accessed before self.field.contribute_to_class has been called.")
+        return self.field.model
+
+    @cached_property
+    def many_to_many(self):
+        return self.field.many_to_many
+
+    @cached_property
+    def many_to_one(self):
+        return self.field.one_to_many
+
+    @cached_property
+    def one_to_many(self):
+        return self.field.many_to_one
+
+    @cached_property
+    def one_to_one(self):
+        return self.field.one_to_one
+
+    def get_lookup(self, lookup_name):
+        return self.field.get_lookup(lookup_name)
+
+    def get_internal_type(self):
+        return self.field.get_internal_type()
+
+    @property
+    def db_type(self):
+        return self.field.db_type
+
+    def __repr__(self):
+        return '<%s: %s.%s>' % (
+            type(self).__name__,
+            self.related_model._meta.app_label,
+            self.related_model._meta.model_name,
+        )
+
+    def get_choices(self, include_blank=True, blank_choice=BLANK_CHOICE_DASH, ordering=()):
+        """
+        Return choices with a default blank choices included, for use
+        as <select> choices for this field.
+
+        Analog of django.db.models.fields.Field.get_choices(), provided
+        initially for utilization by RelatedFieldListFilter.
+        """
+        qs = self.related_model._default_manager.all()
+        if ordering:
+            qs = qs.order_by(*ordering)
+        return (blank_choice if include_blank else []) + [
+            (x.pk, str(x)) for x in qs
+        ]
+
+    def is_hidden(self):
+        """Should the related object be hidden?"""
+        return bool(self.related_name) and self.related_name[-1] == '+'
+
+    def get_joining_columns(self):
+        return self.field.get_reverse_joining_columns()
+
+    def get_extra_restriction(self, where_class, alias, related_alias):
+        return self.field.get_extra_restriction(where_class, related_alias, alias)
+
+    def set_field_name(self):
+        """
+        Set the related field's name, this is not available until later stages
+        of app loading, so set_field_name is called from
+        set_attributes_from_rel()
+        """
+        # By default foreign object doesn't relate to any remote field (for
+        # example custom multicolumn joins currently have no remote field).
+        self.field_name = None
+
+    def get_accessor_name(self, model=None):
+        # This method encapsulates the logic that decides what name to give an
+        # accessor descriptor that retrieves related many-to-one or
+        # many-to-many objects. It uses the lowercased object_name + "_set",
+        # but this can be overridden with the "related_name" option. Due to
+        # backwards compatibility ModelForms need to be able to provide an
+        # alternate model. See BaseInlineFormSet.get_default_prefix().
+        opts = model._meta if model else self.related_model._meta
+        model = model or self.related_model
+        if self.multiple:
+            # If this is a symmetrical m2m relation on self, there is no reverse accessor.
+            if self.symmetrical and model == self.model:
+                return None
+        if self.related_name:
+            return self.related_name
+        return opts.model_name + ('_set' if self.multiple else '')
+
+    def get_path_info(self, filtered_relation=None):
+        return self.field.get_reverse_path_info(filtered_relation)
+
+    def get_cache_name(self):
+        """
+        Return the name of the cache key to use for storing an instance of the
+        forward model on the reverse model.
+        """
+        return self.get_accessor_name()
+
+
+class ManyToOneRel(ForeignObjectRel):
+    """
+    Used by the ForeignKey field to store information about the relation.
+
+    ``_meta.get_fields()`` returns this class to provide access to the field
+    flags for the reverse relation.
+
+    Note: Because we somewhat abuse the Rel objects by using them as reverse
+    fields we get the funny situation where
+    ``ManyToOneRel.many_to_one == False`` and
+    ``ManyToOneRel.one_to_many == True``. This is unfortunate but the actual
+    ManyToOneRel class is a private API and there is work underway to turn
+    reverse relations into actual fields.
+    """
+
+    def __init__(self, field, to, field_name, related_name=None, related_query_name=None,
+                 limit_choices_to=None, parent_link=False, on_delete=None):
+        super().__init__(
+            field, to,
+            related_name=related_name,
+            related_query_name=related_query_name,
+            limit_choices_to=limit_choices_to,
+            parent_link=parent_link,
+            on_delete=on_delete,
+        )
+
+        self.field_name = field_name
+
+    def __getstate__(self):
+        state = self.__dict__.copy()
+        state.pop('related_model', None)
+        return state
+
+    def get_related_field(self):
+        """
+        Return the Field in the 'to' object to which this relationship is tied.
+        """
+        field = self.model._meta.get_field(self.field_name)
+        if not field.concrete:
+            raise exceptions.FieldDoesNotExist("No related field named '%s'" % self.field_name)
+        return field
+
+    def set_field_name(self):
+        self.field_name = self.field_name or self.model._meta.pk.name
+
+
+class OneToOneRel(ManyToOneRel):
+    """
+    Used by OneToOneField to store information about the relation.
+
+    ``_meta.get_fields()`` returns this class to provide access to the field
+    flags for the reverse relation.
+    """
+
+    def __init__(self, field, to, field_name, related_name=None, related_query_name=None,
+                 limit_choices_to=None, parent_link=False, on_delete=None):
+        super().__init__(
+            field, to, field_name,
+            related_name=related_name,
+            related_query_name=related_query_name,
+            limit_choices_to=limit_choices_to,
+            parent_link=parent_link,
+            on_delete=on_delete,
+        )
+
+        self.multiple = False
+
+
+class ManyToManyRel(ForeignObjectRel):
+    """
+    Used by ManyToManyField to store information about the relation.
+
+    ``_meta.get_fields()`` returns this class to provide access to the field
+    flags for the reverse relation.
+    """
+
+    def __init__(self, field, to, related_name=None, related_query_name=None,
+                 limit_choices_to=None, symmetrical=True, through=None,
+                 through_fields=None, db_constraint=True):
+        super().__init__(
+            field, to,
+            related_name=related_name,
+            related_query_name=related_query_name,
+            limit_choices_to=limit_choices_to,
+        )
+
+        if through and not db_constraint:
+            raise ValueError("Can't supply a through model and db_constraint=False")
+        self.through = through
+
+        if through_fields and not through:
+            raise ValueError("Cannot specify through_fields without a through model")
+        self.through_fields = through_fields
+
+        self.symmetrical = symmetrical
+        self.db_constraint = db_constraint
+
+    def get_related_field(self):
+        """
+        Return the field in the 'to' object to which this relationship is tied.
+        Provided for symmetry with ManyToOneRel.
+        """
+        opts = self.through._meta
+        if self.through_fields:
+            field = opts.get_field(self.through_fields[0])
+        else:
+            for field in opts.fields:
+                rel = getattr(field, 'remote_field', None)
+                if rel and rel.model == self.model:
+                    break
+        return field.foreign_related_fields[0]

venv/lib/python3.8/site-packages/django/db/models/functions/__init__.py

@@ -0,0 +1,44 @@
+from .comparison import Cast, Coalesce, Greatest, Least, NullIf
+from .datetime import (
+    Extract, ExtractDay, ExtractHour, ExtractIsoYear, ExtractMinute,
+    ExtractMonth, ExtractQuarter, ExtractSecond, ExtractWeek, ExtractWeekDay,
+    ExtractYear, Now, Trunc, TruncDate, TruncDay, TruncHour, TruncMinute,
+    TruncMonth, TruncQuarter, TruncSecond, TruncTime, TruncWeek, TruncYear,
+)
+from .math import (
+    Abs, ACos, ASin, ATan, ATan2, Ceil, Cos, Cot, Degrees, Exp, Floor, Ln, Log,
+    Mod, Pi, Power, Radians, Round, Sign, Sin, Sqrt, Tan,
+)
+from .text import (
+    MD5, SHA1, SHA224, SHA256, SHA384, SHA512, Chr, Concat, ConcatPair, Left,
+    Length, Lower, LPad, LTrim, Ord, Repeat, Replace, Reverse, Right, RPad,
+    RTrim, StrIndex, Substr, Trim, Upper,
+)
+from .window import (
+    CumeDist, DenseRank, FirstValue, Lag, LastValue, Lead, NthValue, Ntile,
+    PercentRank, Rank, RowNumber,
+)
+
+__all__ = [
+    # comparison and conversion
+    'Cast', 'Coalesce', 'Greatest', 'Least', 'NullIf',
+    # datetime
+    'Extract', 'ExtractDay', 'ExtractHour', 'ExtractMinute', 'ExtractMonth',
+    'ExtractQuarter', 'ExtractSecond', 'ExtractWeek', 'ExtractWeekDay',
+    'ExtractIsoYear', 'ExtractYear', 'Now', 'Trunc', 'TruncDate', 'TruncDay',
+    'TruncHour', 'TruncMinute', 'TruncMonth', 'TruncQuarter', 'TruncSecond',
+    'TruncMinute', 'TruncMonth', 'TruncQuarter', 'TruncSecond', 'TruncTime',
+    'TruncWeek', 'TruncYear',
+    # math
+    'Abs', 'ACos', 'ASin', 'ATan', 'ATan2', 'Ceil', 'Cos', 'Cot', 'Degrees',
+    'Exp', 'Floor', 'Ln', 'Log', 'Mod', 'Pi', 'Power', 'Radians', 'Round',
+    'Sign', 'Sin', 'Sqrt', 'Tan',
+    # text
+    'MD5', 'SHA1', 'SHA224', 'SHA256', 'SHA384', 'SHA512', 'Chr', 'Concat',
+    'ConcatPair', 'Left', 'Length', 'Lower', 'LPad', 'LTrim', 'Ord', 'Repeat',
+    'Replace', 'Reverse', 'Right', 'RPad', 'RTrim', 'StrIndex', 'Substr',
+    'Trim', 'Upper',
+    # window
+    'CumeDist', 'DenseRank', 'FirstValue', 'Lag', 'LastValue', 'Lead',
+    'NthValue', 'Ntile', 'PercentRank', 'Rank', 'RowNumber',
+]

venv/lib/python3.8/site-packages/django/db/models/functions/comparison.py

@@ -0,0 +1,112 @@
+"""Database functions that do comparisons or type conversions."""
+from django.db.models.expressions import Func, Value
+
+
+class Cast(Func):
+    """Coerce an expression to a new field type."""
+    function = 'CAST'
+    template = '%(function)s(%(expressions)s AS %(db_type)s)'
+
+    def __init__(self, expression, output_field):
+        super().__init__(expression, output_field=output_field)
+
+    def as_sql(self, compiler, connection, **extra_context):
+        extra_context['db_type'] = self.output_field.cast_db_type(connection)
+        return super().as_sql(compiler, connection, **extra_context)
+
+    def as_sqlite(self, compiler, connection, **extra_context):
+        db_type = self.output_field.db_type(connection)
+        if db_type in {'datetime', 'time'}:
+            # Use strftime as datetime/time don't keep fractional seconds.
+            template = 'strftime(%%s, %(expressions)s)'
+            sql, params = super().as_sql(compiler, connection, template=template, **extra_context)
+            format_string = '%H:%M:%f' if db_type == 'time' else '%Y-%m-%d %H:%M:%f'
+            params.insert(0, format_string)
+            return sql, params
+        elif db_type == 'date':
+            template = 'date(%(expressions)s)'
+            return super().as_sql(compiler, connection, template=template, **extra_context)
+        return self.as_sql(compiler, connection, **extra_context)
+
+    def as_mysql(self, compiler, connection, **extra_context):
+        # MySQL doesn't support explicit cast to float.
+        template = '(%(expressions)s + 0.0)' if self.output_field.get_internal_type() == 'FloatField' else None
+        return self.as_sql(compiler, connection, template=template, **extra_context)
+
+    def as_postgresql(self, compiler, connection, **extra_context):
+        # CAST would be valid too, but the :: shortcut syntax is more readable.
+        # 'expressions' is wrapped in parentheses in case it's a complex
+        # expression.
+        return self.as_sql(compiler, connection, template='(%(expressions)s)::%(db_type)s', **extra_context)
+
+
+class Coalesce(Func):
+    """Return, from left to right, the first non-null expression."""
+    function = 'COALESCE'
+
+    def __init__(self, *expressions, **extra):
+        if len(expressions) < 2:
+            raise ValueError('Coalesce must take at least two expressions')
+        super().__init__(*expressions, **extra)
+
+    def as_oracle(self, compiler, connection, **extra_context):
+        # Oracle prohibits mixing TextField (NCLOB) and CharField (NVARCHAR2),
+        # so convert all fields to NCLOB when that type is expected.
+        if self.output_field.get_internal_type() == 'TextField':
+            clone = self.copy()
+            clone.set_source_expressions([
+                Func(expression, function='TO_NCLOB') for expression in self.get_source_expressions()
+            ])
+            return super(Coalesce, clone).as_sql(compiler, connection, **extra_context)
+        return self.as_sql(compiler, connection, **extra_context)
+
+
+class Greatest(Func):
+    """
+    Return the maximum expression.
+
+    If any expression is null the return value is database-specific:
+    On PostgreSQL, the maximum not-null expression is returned.
+    On MySQL, Oracle, and SQLite, if any expression is null, null is returned.
+    """
+    function = 'GREATEST'
+
+    def __init__(self, *expressions, **extra):
+        if len(expressions) < 2:
+            raise ValueError('Greatest must take at least two expressions')
+        super().__init__(*expressions, **extra)
+
+    def as_sqlite(self, compiler, connection, **extra_context):
+        """Use the MAX function on SQLite."""
+        return super().as_sqlite(compiler, connection, function='MAX', **extra_context)
+
+
+class Least(Func):
+    """
+    Return the minimum expression.
+
+    If any expression is null the return value is database-specific:
+    On PostgreSQL, return the minimum not-null expression.
+    On MySQL, Oracle, and SQLite, if any expression is null, return null.
+    """
+    function = 'LEAST'
+
+    def __init__(self, *expressions, **extra):
+        if len(expressions) < 2:
+            raise ValueError('Least must take at least two expressions')
+        super().__init__(*expressions, **extra)
+
+    def as_sqlite(self, compiler, connection, **extra_context):
+        """Use the MIN function on SQLite."""
+        return super().as_sqlite(compiler, connection, function='MIN', **extra_context)
+
+
+class NullIf(Func):
+    function = 'NULLIF'
+    arity = 2
+
+    def as_oracle(self, compiler, connection, **extra_context):
+        expression1 = self.get_source_expressions()[0]
+        if isinstance(expression1, Value) and expression1.value is None:
+            raise ValueError('Oracle does not allow Value(None) for expression1.')
+        return super().as_sql(compiler, connection, **extra_context)

venv/lib/python3.8/site-packages/django/db/models/functions/datetime.py

@@ -0,0 +1,320 @@
+from datetime import datetime
+
+from django.conf import settings
+from django.db.models.expressions import Func
+from django.db.models.fields import (
+    DateField, DateTimeField, DurationField, Field, IntegerField, TimeField,
+)
+from django.db.models.lookups import (
+    Transform, YearExact, YearGt, YearGte, YearLt, YearLte,
+)
+from django.utils import timezone
+
+
+class TimezoneMixin:
+    tzinfo = None
+
+    def get_tzname(self):
+        # Timezone conversions must happen to the input datetime *before*
+        # applying a function. 2015-12-31 23:00:00 -02:00 is stored in the
+        # database as 2016-01-01 01:00:00 +00:00. Any results should be
+        # based on the input datetime not the stored datetime.
+        tzname = None
+        if settings.USE_TZ:
+            if self.tzinfo is None:
+                tzname = timezone.get_current_timezone_name()
+            else:
+                tzname = timezone._get_timezone_name(self.tzinfo)
+        return tzname
+
+
+class Extract(TimezoneMixin, Transform):
+    lookup_name = None
+    output_field = IntegerField()
+
+    def __init__(self, expression, lookup_name=None, tzinfo=None, **extra):
+        if self.lookup_name is None:
+            self.lookup_name = lookup_name
+        if self.lookup_name is None:
+            raise ValueError('lookup_name must be provided')
+        self.tzinfo = tzinfo
+        super().__init__(expression, **extra)
+
+    def as_sql(self, compiler, connection):
+        sql, params = compiler.compile(self.lhs)
+        lhs_output_field = self.lhs.output_field
+        if isinstance(lhs_output_field, DateTimeField):
+            tzname = self.get_tzname()
+            sql = connection.ops.datetime_extract_sql(self.lookup_name, sql, tzname)
+        elif isinstance(lhs_output_field, DateField):
+            sql = connection.ops.date_extract_sql(self.lookup_name, sql)
+        elif isinstance(lhs_output_field, TimeField):
+            sql = connection.ops.time_extract_sql(self.lookup_name, sql)
+        elif isinstance(lhs_output_field, DurationField):
+            if not connection.features.has_native_duration_field:
+                raise ValueError('Extract requires native DurationField database support.')
+            sql = connection.ops.time_extract_sql(self.lookup_name, sql)
+        else:
+            # resolve_expression has already validated the output_field so this
+            # assert should never be hit.
+            assert False, "Tried to Extract from an invalid type."
+        return sql, params
+
+    def resolve_expression(self, query=None, allow_joins=True, reuse=None, summarize=False, for_save=False):
+        copy = super().resolve_expression(query, allow_joins, reuse, summarize, for_save)
+        field = copy.lhs.output_field
+        if not isinstance(field, (DateField, DateTimeField, TimeField, DurationField)):
+            raise ValueError(
+                'Extract input expression must be DateField, DateTimeField, '
+                'TimeField, or DurationField.'
+            )
+        # Passing dates to functions expecting datetimes is most likely a mistake.
+        if type(field) == DateField and copy.lookup_name in ('hour', 'minute', 'second'):
+            raise ValueError(
+                "Cannot extract time component '%s' from DateField '%s'. " % (copy.lookup_name, field.name)
+            )
+        if (
+            isinstance(field, DurationField) and
+            copy.lookup_name in ('year', 'iso_year', 'month', 'week', 'week_day', 'quarter')
+        ):
+            raise ValueError(
+                "Cannot extract component '%s' from DurationField '%s'."
+                % (copy.lookup_name, field.name)
+            )
+        return copy
+
+
+class ExtractYear(Extract):
+    lookup_name = 'year'
+
+
+class ExtractIsoYear(Extract):
+    """Return the ISO-8601 week-numbering year."""
+    lookup_name = 'iso_year'
+
+
+class ExtractMonth(Extract):
+    lookup_name = 'month'
+
+
+class ExtractDay(Extract):
+    lookup_name = 'day'
+
+
+class ExtractWeek(Extract):
+    """
+    Return 1-52 or 53, based on ISO-8601, i.e., Monday is the first of the
+    week.
+    """
+    lookup_name = 'week'
+
+
+class ExtractWeekDay(Extract):
+    """
+    Return Sunday=1 through Saturday=7.
+
+    To replicate this in Python: (mydatetime.isoweekday() % 7) + 1
+    """
+    lookup_name = 'week_day'
+
+
+class ExtractQuarter(Extract):
+    lookup_name = 'quarter'
+
+
+class ExtractHour(Extract):
+    lookup_name = 'hour'
+
+
+class ExtractMinute(Extract):
+    lookup_name = 'minute'
+
+
+class ExtractSecond(Extract):
+    lookup_name = 'second'
+
+
+DateField.register_lookup(ExtractYear)
+DateField.register_lookup(ExtractMonth)
+DateField.register_lookup(ExtractDay)
+DateField.register_lookup(ExtractWeekDay)
+DateField.register_lookup(ExtractWeek)
+DateField.register_lookup(ExtractIsoYear)
+DateField.register_lookup(ExtractQuarter)
+
+TimeField.register_lookup(ExtractHour)
+TimeField.register_lookup(ExtractMinute)
+TimeField.register_lookup(ExtractSecond)
+
+DateTimeField.register_lookup(ExtractHour)
+DateTimeField.register_lookup(ExtractMinute)
+DateTimeField.register_lookup(ExtractSecond)
+
+ExtractYear.register_lookup(YearExact)
+ExtractYear.register_lookup(YearGt)
+ExtractYear.register_lookup(YearGte)
+ExtractYear.register_lookup(YearLt)
+ExtractYear.register_lookup(YearLte)
+
+ExtractIsoYear.register_lookup(YearExact)
+ExtractIsoYear.register_lookup(YearGt)
+ExtractIsoYear.register_lookup(YearGte)
+ExtractIsoYear.register_lookup(YearLt)
+ExtractIsoYear.register_lookup(YearLte)
+
+
+class Now(Func):
+    template = 'CURRENT_TIMESTAMP'
+    output_field = DateTimeField()
+
+    def as_postgresql(self, compiler, connection, **extra_context):
+        # PostgreSQL's CURRENT_TIMESTAMP means "the time at the start of the
+        # transaction". Use STATEMENT_TIMESTAMP to be cross-compatible with
+        # other databases.
+        return self.as_sql(compiler, connection, template='STATEMENT_TIMESTAMP()', **extra_context)
+
+
+class TruncBase(TimezoneMixin, Transform):
+    kind = None
+    tzinfo = None
+
+    def __init__(self, expression, output_field=None, tzinfo=None, is_dst=None, **extra):
+        self.tzinfo = tzinfo
+        self.is_dst = is_dst
+        super().__init__(expression, output_field=output_field, **extra)
+
+    def as_sql(self, compiler, connection):
+        inner_sql, inner_params = compiler.compile(self.lhs)
+        if isinstance(self.output_field, DateTimeField):
+            tzname = self.get_tzname()
+            sql = connection.ops.datetime_trunc_sql(self.kind, inner_sql, tzname)
+        elif isinstance(self.output_field, DateField):
+            sql = connection.ops.date_trunc_sql(self.kind, inner_sql)
+        elif isinstance(self.output_field, TimeField):
+            sql = connection.ops.time_trunc_sql(self.kind, inner_sql)
+        else:
+            raise ValueError('Trunc only valid on DateField, TimeField, or DateTimeField.')
+        return sql, inner_params
+
+    def resolve_expression(self, query=None, allow_joins=True, reuse=None, summarize=False, for_save=False):
+        copy = super().resolve_expression(query, allow_joins, reuse, summarize, for_save)
+        field = copy.lhs.output_field
+        # DateTimeField is a subclass of DateField so this works for both.
+        assert isinstance(field, (DateField, TimeField)), (
+            "%r isn't a DateField, TimeField, or DateTimeField." % field.name
+        )
+        # If self.output_field was None, then accessing the field will trigger
+        # the resolver to assign it to self.lhs.output_field.
+        if not isinstance(copy.output_field, (DateField, DateTimeField, TimeField)):
+            raise ValueError('output_field must be either DateField, TimeField, or DateTimeField')
+        # Passing dates or times to functions expecting datetimes is most
+        # likely a mistake.
+        class_output_field = self.__class__.output_field if isinstance(self.__class__.output_field, Field) else None
+        output_field = class_output_field or copy.output_field
+        has_explicit_output_field = class_output_field or field.__class__ is not copy.output_field.__class__
+        if type(field) == DateField and (
+                isinstance(output_field, DateTimeField) or copy.kind in ('hour', 'minute', 'second', 'time')):
+            raise ValueError("Cannot truncate DateField '%s' to %s. " % (
+                field.name, output_field.__class__.__name__ if has_explicit_output_field else 'DateTimeField'
+            ))
+        elif isinstance(field, TimeField) and (
+                isinstance(output_field, DateTimeField) or
+                copy.kind in ('year', 'quarter', 'month', 'week', 'day', 'date')):
+            raise ValueError("Cannot truncate TimeField '%s' to %s. " % (
+                field.name, output_field.__class__.__name__ if has_explicit_output_field else 'DateTimeField'
+            ))
+        return copy
+
+    def convert_value(self, value, expression, connection):
+        if isinstance(self.output_field, DateTimeField):
+            if not settings.USE_TZ:
+                pass
+            elif value is not None:
+                value = value.replace(tzinfo=None)
+                value = timezone.make_aware(value, self.tzinfo, is_dst=self.is_dst)
+            elif not connection.features.has_zoneinfo_database:
+                raise ValueError(
+                    'Database returned an invalid datetime value. Are time '
+                    'zone definitions for your database installed?'
+                )
+        elif isinstance(value, datetime):
+            if value is None:
+                pass
+            elif isinstance(self.output_field, DateField):
+                value = value.date()
+            elif isinstance(self.output_field, TimeField):
+                value = value.time()
+        return value
+
+
+class Trunc(TruncBase):
+
+    def __init__(self, expression, kind, output_field=None, tzinfo=None, is_dst=None, **extra):
+        self.kind = kind
+        super().__init__(
+            expression, output_field=output_field, tzinfo=tzinfo,
+            is_dst=is_dst, **extra
+        )
+
+
+class TruncYear(TruncBase):
+    kind = 'year'
+
+
+class TruncQuarter(TruncBase):
+    kind = 'quarter'
+
+
+class TruncMonth(TruncBase):
+    kind = 'month'
+
+
+class TruncWeek(TruncBase):
+    """Truncate to midnight on the Monday of the week."""
+    kind = 'week'
+
+
+class TruncDay(TruncBase):
+    kind = 'day'
+
+
+class TruncDate(TruncBase):
+    kind = 'date'
+    lookup_name = 'date'
+    output_field = DateField()
+
+    def as_sql(self, compiler, connection):
+        # Cast to date rather than truncate to date.
+        lhs, lhs_params = compiler.compile(self.lhs)
+        tzname = timezone.get_current_timezone_name() if settings.USE_TZ else None
+        sql = connection.ops.datetime_cast_date_sql(lhs, tzname)
+        return sql, lhs_params
+
+
+class TruncTime(TruncBase):
+    kind = 'time'
+    lookup_name = 'time'
+    output_field = TimeField()
+
+    def as_sql(self, compiler, connection):
+        # Cast to time rather than truncate to time.
+        lhs, lhs_params = compiler.compile(self.lhs)
+        tzname = timezone.get_current_timezone_name() if settings.USE_TZ else None
+        sql = connection.ops.datetime_cast_time_sql(lhs, tzname)
+        return sql, lhs_params
+
+
+class TruncHour(TruncBase):
+    kind = 'hour'
+
+
+class TruncMinute(TruncBase):
+    kind = 'minute'
+
+
+class TruncSecond(TruncBase):
+    kind = 'second'
+
+
+DateTimeField.register_lookup(TruncDate)
+DateTimeField.register_lookup(TruncTime)

venv/lib/python3.8/site-packages/django/db/models/functions/math.py

@@ -0,0 +1,166 @@
+import math
+
+from django.db.models.expressions import Func
+from django.db.models.fields import FloatField, IntegerField
+from django.db.models.functions import Cast
+from django.db.models.functions.mixins import (
+    FixDecimalInputMixin, NumericOutputFieldMixin,
+)
+from django.db.models.lookups import Transform
+
+
+class Abs(Transform):
+    function = 'ABS'
+    lookup_name = 'abs'
+
+
+class ACos(NumericOutputFieldMixin, Transform):
+    function = 'ACOS'
+    lookup_name = 'acos'
+
+
+class ASin(NumericOutputFieldMixin, Transform):
+    function = 'ASIN'
+    lookup_name = 'asin'
+
+
+class ATan(NumericOutputFieldMixin, Transform):
+    function = 'ATAN'
+    lookup_name = 'atan'
+
+
+class ATan2(NumericOutputFieldMixin, Func):
+    function = 'ATAN2'
+    arity = 2
+
+    def as_sqlite(self, compiler, connection, **extra_context):
+        if not getattr(connection.ops, 'spatialite', False) or connection.ops.spatial_version >= (5, 0, 0):
+            return self.as_sql(compiler, connection)
+        # This function is usually ATan2(y, x), returning the inverse tangent
+        # of y / x, but it's ATan2(x, y) on SpatiaLite < 5.0.0.
+        # Cast integers to float to avoid inconsistent/buggy behavior if the
+        # arguments are mixed between integer and float or decimal.
+        # https://www.gaia-gis.it/fossil/libspatialite/tktview?name=0f72cca3a2
+        clone = self.copy()
+        clone.set_source_expressions([
+            Cast(expression, FloatField()) if isinstance(expression.output_field, IntegerField)
+            else expression for expression in self.get_source_expressions()[::-1]
+        ])
+        return clone.as_sql(compiler, connection, **extra_context)
+
+
+class Ceil(Transform):
+    function = 'CEILING'
+    lookup_name = 'ceil'
+
+    def as_oracle(self, compiler, connection, **extra_context):
+        return super().as_sql(compiler, connection, function='CEIL', **extra_context)
+
+
+class Cos(NumericOutputFieldMixin, Transform):
+    function = 'COS'
+    lookup_name = 'cos'
+
+
+class Cot(NumericOutputFieldMixin, Transform):
+    function = 'COT'
+    lookup_name = 'cot'
+
+    def as_oracle(self, compiler, connection, **extra_context):
+        return super().as_sql(compiler, connection, template='(1 / TAN(%(expressions)s))', **extra_context)
+
+
+class Degrees(NumericOutputFieldMixin, Transform):
+    function = 'DEGREES'
+    lookup_name = 'degrees'
+
+    def as_oracle(self, compiler, connection, **extra_context):
+        return super().as_sql(
+            compiler, connection,
+            template='((%%(expressions)s) * 180 / %s)' % math.pi,
+            **extra_context
+        )
+
+
+class Exp(NumericOutputFieldMixin, Transform):
+    function = 'EXP'
+    lookup_name = 'exp'
+
+
+class Floor(Transform):
+    function = 'FLOOR'
+    lookup_name = 'floor'
+
+
+class Ln(NumericOutputFieldMixin, Transform):
+    function = 'LN'
+    lookup_name = 'ln'
+
+
+class Log(FixDecimalInputMixin, NumericOutputFieldMixin, Func):
+    function = 'LOG'
+    arity = 2
+
+    def as_sqlite(self, compiler, connection, **extra_context):
+        if not getattr(connection.ops, 'spatialite', False):
+            return self.as_sql(compiler, connection)
+        # This function is usually Log(b, x) returning the logarithm of x to
+        # the base b, but on SpatiaLite it's Log(x, b).
+        clone = self.copy()
+        clone.set_source_expressions(self.get_source_expressions()[::-1])
+        return clone.as_sql(compiler, connection, **extra_context)
+
+
+class Mod(FixDecimalInputMixin, NumericOutputFieldMixin, Func):
+    function = 'MOD'
+    arity = 2
+
+
+class Pi(NumericOutputFieldMixin, Func):
+    function = 'PI'
+    arity = 0
+
+    def as_oracle(self, compiler, connection, **extra_context):
+        return super().as_sql(compiler, connection, template=str(math.pi), **extra_context)
+
+
+class Power(NumericOutputFieldMixin, Func):
+    function = 'POWER'
+    arity = 2
+
+
+class Radians(NumericOutputFieldMixin, Transform):
+    function = 'RADIANS'
+    lookup_name = 'radians'
+
+    def as_oracle(self, compiler, connection, **extra_context):
+        return super().as_sql(
+            compiler, connection,
+            template='((%%(expressions)s) * %s / 180)' % math.pi,
+            **extra_context
+        )
+
+
+class Round(Transform):
+    function = 'ROUND'
+    lookup_name = 'round'
+
+
+class Sign(Transform):
+    function = 'SIGN'
+    lookup_name = 'sign'
+
+
+class Sin(NumericOutputFieldMixin, Transform):
+    function = 'SIN'
+    lookup_name = 'sin'
+
+
+class Sqrt(NumericOutputFieldMixin, Transform):
+    function = 'SQRT'
+    lookup_name = 'sqrt'
+
+
+class Tan(NumericOutputFieldMixin, Transform):
+    function = 'TAN'
+    lookup_name = 'tan'

venv/lib/python3.8/site-packages/django/db/models/functions/mixins.py

@@ -0,0 +1,50 @@
+import sys
+
+from django.db.models.fields import DecimalField, FloatField, IntegerField
+from django.db.models.functions import Cast
+
+
+class FixDecimalInputMixin:
+
+    def as_postgresql(self, compiler, connection, **extra_context):
+        # Cast FloatField to DecimalField as PostgreSQL doesn't support the
+        # following function signatures:
+        # - LOG(double, double)
+        # - MOD(double, double)
+        output_field = DecimalField(decimal_places=sys.float_info.dig, max_digits=1000)
+        clone = self.copy()
+        clone.set_source_expressions([
+            Cast(expression, output_field) if isinstance(expression.output_field, FloatField)
+            else expression for expression in self.get_source_expressions()
+        ])
+        return clone.as_sql(compiler, connection, **extra_context)
+
+
+class FixDurationInputMixin:
+
+    def as_mysql(self, compiler, connection, **extra_context):
+        sql, params = super().as_sql(compiler, connection, **extra_context)
+        if self.output_field.get_internal_type() == 'DurationField':
+            sql = 'CAST(%s AS SIGNED)' % sql
+        return sql, params
+
+    def as_oracle(self, compiler, connection, **extra_context):
+        if self.output_field.get_internal_type() == 'DurationField':
+            expression = self.get_source_expressions()[0]
+            options = self._get_repr_options()
+            from django.db.backends.oracle.functions import IntervalToSeconds, SecondsToInterval
+            return compiler.compile(
+                SecondsToInterval(self.__class__(IntervalToSeconds(expression), **options))
+            )
+        return super().as_sql(compiler, connection, **extra_context)
+
+
+class NumericOutputFieldMixin:
+
+    def _resolve_output_field(self):
+        source_fields = self.get_source_fields()
+        if any(isinstance(s, DecimalField) for s in source_fields):
+            return DecimalField()
+        if any(isinstance(s, IntegerField) for s in source_fields):
+            return FloatField()
+        return super()._resolve_output_field() if source_fields else FloatField()

venv/lib/python3.8/site-packages/django/db/models/functions/text.py

@@ -0,0 +1,335 @@
+from django.db.models.expressions import Func, Value
+from django.db.models.fields import IntegerField
+from django.db.models.functions import Coalesce
+from django.db.models.lookups import Transform
+from django.db.utils import NotSupportedError
+
+
+class BytesToCharFieldConversionMixin:
+    """
+    Convert CharField results from bytes to str.
+
+    MySQL returns long data types (bytes) instead of chars when it can't
+    determine the length of the result string. For example:
+        LPAD(column1, CHAR_LENGTH(column2), ' ')
+    returns the LONGTEXT (bytes) instead of VARCHAR.
+    """
+    def convert_value(self, value, expression, connection):
+        if connection.features.db_functions_convert_bytes_to_str:
+            if self.output_field.get_internal_type() == 'CharField' and isinstance(value, bytes):
+                return value.decode()
+        return super().convert_value(value, expression, connection)
+
+
+class MySQLSHA2Mixin:
+    def as_mysql(self, compiler, connection, **extra_content):
+        return super().as_sql(
+            compiler,
+            connection,
+            template='SHA2(%%(expressions)s, %s)' % self.function[3:],
+            **extra_content,
+        )
+
+
+class OracleHashMixin:
+    def as_oracle(self, compiler, connection, **extra_context):
+        return super().as_sql(
+            compiler,
+            connection,
+            template=(
+                "LOWER(RAWTOHEX(STANDARD_HASH(UTL_I18N.STRING_TO_RAW("
+                "%(expressions)s, 'AL32UTF8'), '%(function)s')))"
+            ),
+            **extra_context,
+        )
+
+
+class PostgreSQLSHAMixin:
+    def as_postgresql(self, compiler, connection, **extra_content):
+        return super().as_sql(
+            compiler,
+            connection,
+            template="ENCODE(DIGEST(%(expressions)s, '%(function)s'), 'hex')",
+            function=self.function.lower(),
+            **extra_content,
+        )
+
+
+class Chr(Transform):
+    function = 'CHR'
+    lookup_name = 'chr'
+
+    def as_mysql(self, compiler, connection, **extra_context):
+        return super().as_sql(
+            compiler, connection, function='CHAR',
+            template='%(function)s(%(expressions)s USING utf16)',
+            **extra_context
+        )
+
+    def as_oracle(self, compiler, connection, **extra_context):
+        return super().as_sql(
+            compiler, connection,
+            template='%(function)s(%(expressions)s USING NCHAR_CS)',
+            **extra_context
+        )
+
+    def as_sqlite(self, compiler, connection, **extra_context):
+        return super().as_sql(compiler, connection, function='CHAR', **extra_context)
+
+
+class ConcatPair(Func):
+    """
+    Concatenate two arguments together. This is used by `Concat` because not
+    all backend databases support more than two arguments.
+    """
+    function = 'CONCAT'
+
+    def as_sqlite(self, compiler, connection, **extra_context):
+        coalesced = self.coalesce()
+        return super(ConcatPair, coalesced).as_sql(
+            compiler, connection, template='%(expressions)s', arg_joiner=' || ',
+            **extra_context
+        )
+
+    def as_mysql(self, compiler, connection, **extra_context):
+        # Use CONCAT_WS with an empty separator so that NULLs are ignored.
+        return super().as_sql(
+            compiler, connection, function='CONCAT_WS',
+            template="%(function)s('', %(expressions)s)",
+            **extra_context
+        )
+
+    def coalesce(self):
+        # null on either side results in null for expression, wrap with coalesce
+        c = self.copy()
+        c.set_source_expressions([
+            Coalesce(expression, Value('')) for expression in c.get_source_expressions()
+        ])
+        return c
+
+
+class Concat(Func):
+    """
+    Concatenate text fields together. Backends that result in an entire
+    null expression when any arguments are null will wrap each argument in
+    coalesce functions to ensure a non-null result.
+    """
+    function = None
+    template = "%(expressions)s"
+
+    def __init__(self, *expressions, **extra):
+        if len(expressions) < 2:
+            raise ValueError('Concat must take at least two expressions')
+        paired = self._paired(expressions)
+        super().__init__(paired, **extra)
+
+    def _paired(self, expressions):
+        # wrap pairs of expressions in successive concat functions
+        # exp = [a, b, c, d]
+        # -> ConcatPair(a, ConcatPair(b, ConcatPair(c, d))))
+        if len(expressions) == 2:
+            return ConcatPair(*expressions)
+        return ConcatPair(expressions[0], self._paired(expressions[1:]))
+
+
+class Left(Func):
+    function = 'LEFT'
+    arity = 2
+
+    def __init__(self, expression, length, **extra):
+        """
+        expression: the name of a field, or an expression returning a string
+        length: the number of characters to return from the start of the string
+        """
+        if not hasattr(length, 'resolve_expression'):
+            if length < 1:
+                raise ValueError("'length' must be greater than 0.")
+        super().__init__(expression, length, **extra)
+
+    def get_substr(self):
+        return Substr(self.source_expressions[0], Value(1), self.source_expressions[1])
+
+    def as_oracle(self, compiler, connection, **extra_context):
+        return self.get_substr().as_oracle(compiler, connection, **extra_context)
+
+    def as_sqlite(self, compiler, connection, **extra_context):
+        return self.get_substr().as_sqlite(compiler, connection, **extra_context)
+
+
+class Length(Transform):
+    """Return the number of characters in the expression."""
+    function = 'LENGTH'
+    lookup_name = 'length'
+    output_field = IntegerField()
+
+    def as_mysql(self, compiler, connection, **extra_context):
+        return super().as_sql(compiler, connection, function='CHAR_LENGTH', **extra_context)
+
+
+class Lower(Transform):
+    function = 'LOWER'
+    lookup_name = 'lower'
+
+
+class LPad(BytesToCharFieldConversionMixin, Func):
+    function = 'LPAD'
+
+    def __init__(self, expression, length, fill_text=Value(' '), **extra):
+        if not hasattr(length, 'resolve_expression') and length is not None and length < 0:
+            raise ValueError("'length' must be greater or equal to 0.")
+        super().__init__(expression, length, fill_text, **extra)
+
+
+class LTrim(Transform):
+    function = 'LTRIM'
+    lookup_name = 'ltrim'
+
+
+class MD5(OracleHashMixin, Transform):
+    function = 'MD5'
+    lookup_name = 'md5'
+
+
+class Ord(Transform):
+    function = 'ASCII'
+    lookup_name = 'ord'
+    output_field = IntegerField()
+
+    def as_mysql(self, compiler, connection, **extra_context):
+        return super().as_sql(compiler, connection, function='ORD', **extra_context)
+
+    def as_sqlite(self, compiler, connection, **extra_context):
+        return super().as_sql(compiler, connection, function='UNICODE', **extra_context)
+
+
+class Repeat(BytesToCharFieldConversionMixin, Func):
+    function = 'REPEAT'
+
+    def __init__(self, expression, number, **extra):
+        if not hasattr(number, 'resolve_expression') and number is not None and number < 0:
+            raise ValueError("'number' must be greater or equal to 0.")
+        super().__init__(expression, number, **extra)
+
+    def as_oracle(self, compiler, connection, **extra_context):
+        expression, number = self.source_expressions
+        length = None if number is None else Length(expression) * number
+        rpad = RPad(expression, length, expression)
+        return rpad.as_sql(compiler, connection, **extra_context)
+
+
+class Replace(Func):
+    function = 'REPLACE'
+
+    def __init__(self, expression, text, replacement=Value(''), **extra):
+        super().__init__(expression, text, replacement, **extra)
+
+
+class Reverse(Transform):
+    function = 'REVERSE'
+    lookup_name = 'reverse'
+
+    def as_oracle(self, compiler, connection, **extra_context):
+        # REVERSE in Oracle is undocumented and doesn't support multi-byte
+        # strings. Use a special subquery instead.
+        return super().as_sql(
+            compiler, connection,
+            template=(
+                '(SELECT LISTAGG(s) WITHIN GROUP (ORDER BY n DESC) FROM '
+                '(SELECT LEVEL n, SUBSTR(%(expressions)s, LEVEL, 1) s '
+                'FROM DUAL CONNECT BY LEVEL <= LENGTH(%(expressions)s)) '
+                'GROUP BY %(expressions)s)'
+            ),
+            **extra_context
+        )
+
+
+class Right(Left):
+    function = 'RIGHT'
+
+    def get_substr(self):
+        return Substr(self.source_expressions[0], self.source_expressions[1] * Value(-1))
+
+
+class RPad(LPad):
+    function = 'RPAD'
+
+
+class RTrim(Transform):
+    function = 'RTRIM'
+    lookup_name = 'rtrim'
+
+
+class SHA1(OracleHashMixin, PostgreSQLSHAMixin, Transform):
+    function = 'SHA1'
+    lookup_name = 'sha1'
+
+
+class SHA224(MySQLSHA2Mixin, PostgreSQLSHAMixin, Transform):
+    function = 'SHA224'
+    lookup_name = 'sha224'
+
+    def as_oracle(self, compiler, connection, **extra_context):
+        raise NotSupportedError('SHA224 is not supported on Oracle.')
+
+
+class SHA256(MySQLSHA2Mixin, OracleHashMixin, PostgreSQLSHAMixin, Transform):
+    function = 'SHA256'
+    lookup_name = 'sha256'
+
+
+class SHA384(MySQLSHA2Mixin, OracleHashMixin, PostgreSQLSHAMixin, Transform):
+    function = 'SHA384'
+    lookup_name = 'sha384'
+
+
+class SHA512(MySQLSHA2Mixin, OracleHashMixin, PostgreSQLSHAMixin, Transform):
+    function = 'SHA512'
+    lookup_name = 'sha512'
+
+
+class StrIndex(Func):
+    """
+    Return a positive integer corresponding to the 1-indexed position of the
+    first occurrence of a substring inside another string, or 0 if the
+    substring is not found.
+    """
+    function = 'INSTR'
+    arity = 2
+    output_field = IntegerField()
+
+    def as_postgresql(self, compiler, connection, **extra_context):
+        return super().as_sql(compiler, connection, function='STRPOS', **extra_context)
+
+
+class Substr(Func):
+    function = 'SUBSTRING'
+
+    def __init__(self, expression, pos, length=None, **extra):
+        """
+        expression: the name of a field, or an expression returning a string
+        pos: an integer > 0, or an expression returning an integer
+        length: an optional number of characters to return
+        """
+        if not hasattr(pos, 'resolve_expression'):
+            if pos < 1:
+                raise ValueError("'pos' must be greater than 0")
+        expressions = [expression, pos]
+        if length is not None:
+            expressions.append(length)
+        super().__init__(*expressions, **extra)
+
+    def as_sqlite(self, compiler, connection, **extra_context):
+        return super().as_sql(compiler, connection, function='SUBSTR', **extra_context)
+
+    def as_oracle(self, compiler, connection, **extra_context):
+        return super().as_sql(compiler, connection, function='SUBSTR', **extra_context)
+
+
+class Trim(Transform):
+    function = 'TRIM'
+    lookup_name = 'trim'
+
+
+class Upper(Transform):
+    function = 'UPPER'
+    lookup_name = 'upper'

venv/lib/python3.8/site-packages/django/db/models/functions/window.py

@@ -0,0 +1,108 @@
+from django.db.models.expressions import Func
+from django.db.models.fields import FloatField, IntegerField
+
+__all__ = [
+    'CumeDist', 'DenseRank', 'FirstValue', 'Lag', 'LastValue', 'Lead',
+    'NthValue', 'Ntile', 'PercentRank', 'Rank', 'RowNumber',
+]
+
+
+class CumeDist(Func):
+    function = 'CUME_DIST'
+    output_field = FloatField()
+    window_compatible = True
+
+
+class DenseRank(Func):
+    function = 'DENSE_RANK'
+    output_field = IntegerField()
+    window_compatible = True
+
+
+class FirstValue(Func):
+    arity = 1
+    function = 'FIRST_VALUE'
+    window_compatible = True
+
+
+class LagLeadFunction(Func):
+    window_compatible = True
+
+    def __init__(self, expression, offset=1, default=None, **extra):
+        if expression is None:
+            raise ValueError(
+                '%s requires a non-null source expression.' %
+                self.__class__.__name__
+            )
+        if offset is None or offset <= 0:
+            raise ValueError(
+                '%s requires a positive integer for the offset.' %
+                self.__class__.__name__
+            )
+        args = (expression, offset)
+        if default is not None:
+            args += (default,)
+        super().__init__(*args, **extra)
+
+    def _resolve_output_field(self):
+        sources = self.get_source_expressions()
+        return sources[0].output_field
+
+
+class Lag(LagLeadFunction):
+    function = 'LAG'
+
+
+class LastValue(Func):
+    arity = 1
+    function = 'LAST_VALUE'
+    window_compatible = True
+
+
+class Lead(LagLeadFunction):
+    function = 'LEAD'
+
+
+class NthValue(Func):
+    function = 'NTH_VALUE'
+    window_compatible = True
+
+    def __init__(self, expression, nth=1, **extra):
+        if expression is None:
+            raise ValueError('%s requires a non-null source expression.' % self.__class__.__name__)
+        if nth is None or nth <= 0:
+            raise ValueError('%s requires a positive integer as for nth.' % self.__class__.__name__)
+        super().__init__(expression, nth, **extra)
+
+    def _resolve_output_field(self):
+        sources = self.get_source_expressions()
+        return sources[0].output_field
+
+
+class Ntile(Func):
+    function = 'NTILE'
+    output_field = IntegerField()
+    window_compatible = True
+
+    def __init__(self, num_buckets=1, **extra):
+        if num_buckets <= 0:
+            raise ValueError('num_buckets must be greater than 0.')
+        super().__init__(num_buckets, **extra)
+
+
+class PercentRank(Func):
+    function = 'PERCENT_RANK'
+    output_field = FloatField()
+    window_compatible = True
+
+
+class Rank(Func):
+    function = 'RANK'
+    output_field = IntegerField()
+    window_compatible = True
+
+
+class RowNumber(Func):
+    function = 'ROW_NUMBER'
+    output_field = IntegerField()
+    window_compatible = True

venv/lib/python3.8/site-packages/django/db/models/indexes.py

@@ -0,0 +1,115 @@
+from django.db.backends.utils import names_digest, split_identifier
+from django.db.models.query_utils import Q
+from django.db.models.sql import Query
+
+__all__ = ['Index']
+
+
+class Index:
+    suffix = 'idx'
+    # The max length of the name of the index (restricted to 30 for
+    # cross-database compatibility with Oracle)
+    max_name_length = 30
+
+    def __init__(self, *, fields=(), name=None, db_tablespace=None, opclasses=(), condition=None):
+        if opclasses and not name:
+            raise ValueError('An index must be named to use opclasses.')
+        if not isinstance(condition, (type(None), Q)):
+            raise ValueError('Index.condition must be a Q instance.')
+        if condition and not name:
+            raise ValueError('An index must be named to use condition.')
+        if not isinstance(fields, (list, tuple)):
+            raise ValueError('Index.fields must be a list or tuple.')
+        if not isinstance(opclasses, (list, tuple)):
+            raise ValueError('Index.opclasses must be a list or tuple.')
+        if opclasses and len(fields) != len(opclasses):
+            raise ValueError('Index.fields and Index.opclasses must have the same number of elements.')
+        if not fields:
+            raise ValueError('At least one field is required to define an index.')
+        self.fields = list(fields)
+        # A list of 2-tuple with the field name and ordering ('' or 'DESC').
+        self.fields_orders = [
+            (field_name[1:], 'DESC') if field_name.startswith('-') else (field_name, '')
+            for field_name in self.fields
+        ]
+        self.name = name or ''
+        self.db_tablespace = db_tablespace
+        self.opclasses = opclasses
+        self.condition = condition
+
+    def _get_condition_sql(self, model, schema_editor):
+        if self.condition is None:
+            return None
+        query = Query(model=model)
+        where = query.build_where(self.condition)
+        compiler = query.get_compiler(connection=schema_editor.connection)
+        sql, params = where.as_sql(compiler, schema_editor.connection)
+        return sql % tuple(schema_editor.quote_value(p) for p in params)
+
+    def create_sql(self, model, schema_editor, using='', **kwargs):
+        fields = [model._meta.get_field(field_name) for field_name, _ in self.fields_orders]
+        col_suffixes = [order[1] for order in self.fields_orders]
+        condition = self._get_condition_sql(model, schema_editor)
+        return schema_editor._create_index_sql(
+            model, fields, name=self.name, using=using, db_tablespace=self.db_tablespace,
+            col_suffixes=col_suffixes, opclasses=self.opclasses, condition=condition,
+            **kwargs,
+        )
+
+    def remove_sql(self, model, schema_editor, **kwargs):
+        return schema_editor._delete_index_sql(model, self.name, **kwargs)
+
+    def deconstruct(self):
+        path = '%s.%s' % (self.__class__.__module__, self.__class__.__name__)
+        path = path.replace('django.db.models.indexes', 'django.db.models')
+        kwargs = {'fields': self.fields, 'name': self.name}
+        if self.db_tablespace is not None:
+            kwargs['db_tablespace'] = self.db_tablespace
+        if self.opclasses:
+            kwargs['opclasses'] = self.opclasses
+        if self.condition:
+            kwargs['condition'] = self.condition
+        return (path, (), kwargs)
+
+    def clone(self):
+        """Create a copy of this Index."""
+        _, _, kwargs = self.deconstruct()
+        return self.__class__(**kwargs)
+
+    def set_name_with_model(self, model):
+        """
+        Generate a unique name for the index.
+
+        The name is divided into 3 parts - table name (12 chars), field name
+        (8 chars) and unique hash + suffix (10 chars). Each part is made to
+        fit its size by truncating the excess length.
+        """
+        _, table_name = split_identifier(model._meta.db_table)
+        column_names = [model._meta.get_field(field_name).column for field_name, order in self.fields_orders]
+        column_names_with_order = [
+            (('-%s' if order else '%s') % column_name)
+            for column_name, (field_name, order) in zip(column_names, self.fields_orders)
+        ]
+        # The length of the parts of the name is based on the default max
+        # length of 30 characters.
+        hash_data = [table_name] + column_names_with_order + [self.suffix]
+        self.name = '%s_%s_%s' % (
+            table_name[:11],
+            column_names[0][:7],
+            '%s_%s' % (names_digest(*hash_data, length=6), self.suffix),
+        )
+        assert len(self.name) <= self.max_name_length, (
+            'Index too long for multiple database support. Is self.suffix '
+            'longer than 3 characters?'
+        )
+        if self.name[0] == '_' or self.name[0].isdigit():
+            self.name = 'D%s' % self.name[1:]
+
+    def __repr__(self):
+        return "<%s: fields='%s'%s>" % (
+            self.__class__.__name__, ', '.join(self.fields),
+            '' if self.condition is None else ', condition=%s' % self.condition,
+        )
+
+    def __eq__(self, other):
+        return (self.__class__ == other.__class__) and (self.deconstruct() == other.deconstruct())

venv/lib/python3.8/site-packages/django/db/models/lookups.py

@@ -0,0 +1,550 @@
+import itertools
+import math
+from copy import copy
+
+from django.core.exceptions import EmptyResultSet
+from django.db.models.expressions import Case, Exists, Func, Value, When
+from django.db.models.fields import (
+    BooleanField, DateTimeField, Field, IntegerField,
+)
+from django.db.models.query_utils import RegisterLookupMixin
+from django.utils.datastructures import OrderedSet
+from django.utils.functional import cached_property
+
+
+class Lookup:
+    lookup_name = None
+    prepare_rhs = True
+    can_use_none_as_rhs = False
+
+    def __init__(self, lhs, rhs):
+        self.lhs, self.rhs = lhs, rhs
+        self.rhs = self.get_prep_lookup()
+        if hasattr(self.lhs, 'get_bilateral_transforms'):
+            bilateral_transforms = self.lhs.get_bilateral_transforms()
+        else:
+            bilateral_transforms = []
+        if bilateral_transforms:
+            # Warn the user as soon as possible if they are trying to apply
+            # a bilateral transformation on a nested QuerySet: that won't work.
+            from django.db.models.sql.query import Query  # avoid circular import
+            if isinstance(rhs, Query):
+                raise NotImplementedError("Bilateral transformations on nested querysets are not implemented.")
+        self.bilateral_transforms = bilateral_transforms
+
+    def apply_bilateral_transforms(self, value):
+        for transform in self.bilateral_transforms:
+            value = transform(value)
+        return value
+
+    def batch_process_rhs(self, compiler, connection, rhs=None):
+        if rhs is None:
+            rhs = self.rhs
+        if self.bilateral_transforms:
+            sqls, sqls_params = [], []
+            for p in rhs:
+                value = Value(p, output_field=self.lhs.output_field)
+                value = self.apply_bilateral_transforms(value)
+                value = value.resolve_expression(compiler.query)
+                sql, sql_params = compiler.compile(value)
+                sqls.append(sql)
+                sqls_params.extend(sql_params)
+        else:
+            _, params = self.get_db_prep_lookup(rhs, connection)
+            sqls, sqls_params = ['%s'] * len(params), params
+        return sqls, sqls_params
+
+    def get_source_expressions(self):
+        if self.rhs_is_direct_value():
+            return [self.lhs]
+        return [self.lhs, self.rhs]
+
+    def set_source_expressions(self, new_exprs):
+        if len(new_exprs) == 1:
+            self.lhs = new_exprs[0]
+        else:
+            self.lhs, self.rhs = new_exprs
+
+    def get_prep_lookup(self):
+        if hasattr(self.rhs, 'resolve_expression'):
+            return self.rhs
+        if self.prepare_rhs and hasattr(self.lhs.output_field, 'get_prep_value'):
+            return self.lhs.output_field.get_prep_value(self.rhs)
+        return self.rhs
+
+    def get_db_prep_lookup(self, value, connection):
+        return ('%s', [value])
+
+    def process_lhs(self, compiler, connection, lhs=None):
+        lhs = lhs or self.lhs
+        if hasattr(lhs, 'resolve_expression'):
+            lhs = lhs.resolve_expression(compiler.query)
+        return compiler.compile(lhs)
+
+    def process_rhs(self, compiler, connection):
+        value = self.rhs
+        if self.bilateral_transforms:
+            if self.rhs_is_direct_value():
+                # Do not call get_db_prep_lookup here as the value will be
+                # transformed before being used for lookup
+                value = Value(value, output_field=self.lhs.output_field)
+            value = self.apply_bilateral_transforms(value)
+            value = value.resolve_expression(compiler.query)
+        if hasattr(value, 'as_sql'):
+            return compiler.compile(value)
+        else:
+            return self.get_db_prep_lookup(value, connection)
+
+    def rhs_is_direct_value(self):
+        return not hasattr(self.rhs, 'as_sql')
+
+    def relabeled_clone(self, relabels):
+        new = copy(self)
+        new.lhs = new.lhs.relabeled_clone(relabels)
+        if hasattr(new.rhs, 'relabeled_clone'):
+            new.rhs = new.rhs.relabeled_clone(relabels)
+        return new
+
+    def get_group_by_cols(self, alias=None):
+        cols = self.lhs.get_group_by_cols()
+        if hasattr(self.rhs, 'get_group_by_cols'):
+            cols.extend(self.rhs.get_group_by_cols())
+        return cols
+
+    def as_sql(self, compiler, connection):
+        raise NotImplementedError
+
+    def as_oracle(self, compiler, connection):
+        # Oracle doesn't allow EXISTS() to be compared to another expression
+        # unless it's wrapped in a CASE WHEN.
+        wrapped = False
+        exprs = []
+        for expr in (self.lhs, self.rhs):
+            if isinstance(expr, Exists):
+                expr = Case(When(expr, then=True), default=False, output_field=BooleanField())
+                wrapped = True
+            exprs.append(expr)
+        lookup = type(self)(*exprs) if wrapped else self
+        return lookup.as_sql(compiler, connection)
+
+    @cached_property
+    def contains_aggregate(self):
+        return self.lhs.contains_aggregate or getattr(self.rhs, 'contains_aggregate', False)
+
+    @cached_property
+    def contains_over_clause(self):
+        return self.lhs.contains_over_clause or getattr(self.rhs, 'contains_over_clause', False)
+
+    @property
+    def is_summary(self):
+        return self.lhs.is_summary or getattr(self.rhs, 'is_summary', False)
+
+
+class Transform(RegisterLookupMixin, Func):
+    """
+    RegisterLookupMixin() is first so that get_lookup() and get_transform()
+    first examine self and then check output_field.
+    """
+    bilateral = False
+    arity = 1
+
+    @property
+    def lhs(self):
+        return self.get_source_expressions()[0]
+
+    def get_bilateral_transforms(self):
+        if hasattr(self.lhs, 'get_bilateral_transforms'):
+            bilateral_transforms = self.lhs.get_bilateral_transforms()
+        else:
+            bilateral_transforms = []
+        if self.bilateral:
+            bilateral_transforms.append(self.__class__)
+        return bilateral_transforms
+
+
+class BuiltinLookup(Lookup):
+    def process_lhs(self, compiler, connection, lhs=None):
+        lhs_sql, params = super().process_lhs(compiler, connection, lhs)
+        field_internal_type = self.lhs.output_field.get_internal_type()
+        db_type = self.lhs.output_field.db_type(connection=connection)
+        lhs_sql = connection.ops.field_cast_sql(
+            db_type, field_internal_type) % lhs_sql
+        lhs_sql = connection.ops.lookup_cast(self.lookup_name, field_internal_type) % lhs_sql
+        return lhs_sql, list(params)
+
+    def as_sql(self, compiler, connection):
+        lhs_sql, params = self.process_lhs(compiler, connection)
+        rhs_sql, rhs_params = self.process_rhs(compiler, connection)
+        params.extend(rhs_params)
+        rhs_sql = self.get_rhs_op(connection, rhs_sql)
+        return '%s %s' % (lhs_sql, rhs_sql), params
+
+    def get_rhs_op(self, connection, rhs):
+        return connection.operators[self.lookup_name] % rhs
+
+
+class FieldGetDbPrepValueMixin:
+    """
+    Some lookups require Field.get_db_prep_value() to be called on their
+    inputs.
+    """
+    get_db_prep_lookup_value_is_iterable = False
+
+    def get_db_prep_lookup(self, value, connection):
+        # For relational fields, use the 'target_field' attribute of the
+        # output_field.
+        field = getattr(self.lhs.output_field, 'target_field', None)
+        get_db_prep_value = getattr(field, 'get_db_prep_value', None) or self.lhs.output_field.get_db_prep_value
+        return (
+            '%s',
+            [get_db_prep_value(v, connection, prepared=True) for v in value]
+            if self.get_db_prep_lookup_value_is_iterable else
+            [get_db_prep_value(value, connection, prepared=True)]
+        )
+
+
+class FieldGetDbPrepValueIterableMixin(FieldGetDbPrepValueMixin):
+    """
+    Some lookups require Field.get_db_prep_value() to be called on each value
+    in an iterable.
+    """
+    get_db_prep_lookup_value_is_iterable = True
+
+    def get_prep_lookup(self):
+        if hasattr(self.rhs, 'resolve_expression'):
+            return self.rhs
+        prepared_values = []
+        for rhs_value in self.rhs:
+            if hasattr(rhs_value, 'resolve_expression'):
+                # An expression will be handled by the database but can coexist
+                # alongside real values.
+                pass
+            elif self.prepare_rhs and hasattr(self.lhs.output_field, 'get_prep_value'):
+                rhs_value = self.lhs.output_field.get_prep_value(rhs_value)
+            prepared_values.append(rhs_value)
+        return prepared_values
+
+    def process_rhs(self, compiler, connection):
+        if self.rhs_is_direct_value():
+            # rhs should be an iterable of values. Use batch_process_rhs()
+            # to prepare/transform those values.
+            return self.batch_process_rhs(compiler, connection)
+        else:
+            return super().process_rhs(compiler, connection)
+
+    def resolve_expression_parameter(self, compiler, connection, sql, param):
+        params = [param]
+        if hasattr(param, 'resolve_expression'):
+            param = param.resolve_expression(compiler.query)
+        if hasattr(param, 'as_sql'):
+            sql, params = param.as_sql(compiler, connection)
+        return sql, params
+
+    def batch_process_rhs(self, compiler, connection, rhs=None):
+        pre_processed = super().batch_process_rhs(compiler, connection, rhs)
+        # The params list may contain expressions which compile to a
+        # sql/param pair. Zip them to get sql and param pairs that refer to the
+        # same argument and attempt to replace them with the result of
+        # compiling the param step.
+        sql, params = zip(*(
+            self.resolve_expression_parameter(compiler, connection, sql, param)
+            for sql, param in zip(*pre_processed)
+        ))
+        params = itertools.chain.from_iterable(params)
+        return sql, tuple(params)
+
+
+@Field.register_lookup
+class Exact(FieldGetDbPrepValueMixin, BuiltinLookup):
+    lookup_name = 'exact'
+
+    def process_rhs(self, compiler, connection):
+        from django.db.models.sql.query import Query
+        if isinstance(self.rhs, Query):
+            if self.rhs.has_limit_one():
+                if not self.rhs.has_select_fields:
+                    self.rhs.clear_select_clause()
+                    self.rhs.add_fields(['pk'])
+            else:
+                raise ValueError(
+                    'The QuerySet value for an exact lookup must be limited to '
+                    'one result using slicing.'
+                )
+        return super().process_rhs(compiler, connection)
+
+
+@Field.register_lookup
+class IExact(BuiltinLookup):
+    lookup_name = 'iexact'
+    prepare_rhs = False
+
+    def process_rhs(self, qn, connection):
+        rhs, params = super().process_rhs(qn, connection)
+        if params:
+            params[0] = connection.ops.prep_for_iexact_query(params[0])
+        return rhs, params
+
+
+@Field.register_lookup
+class GreaterThan(FieldGetDbPrepValueMixin, BuiltinLookup):
+    lookup_name = 'gt'
+
+
+@Field.register_lookup
+class GreaterThanOrEqual(FieldGetDbPrepValueMixin, BuiltinLookup):
+    lookup_name = 'gte'
+
+
+@Field.register_lookup
+class LessThan(FieldGetDbPrepValueMixin, BuiltinLookup):
+    lookup_name = 'lt'
+
+
+@Field.register_lookup
+class LessThanOrEqual(FieldGetDbPrepValueMixin, BuiltinLookup):
+    lookup_name = 'lte'
+
+
+class IntegerFieldFloatRounding:
+    """
+    Allow floats to work as query values for IntegerField. Without this, the
+    decimal portion of the float would always be discarded.
+    """
+    def get_prep_lookup(self):
+        if isinstance(self.rhs, float):
+            self.rhs = math.ceil(self.rhs)
+        return super().get_prep_lookup()
+
+
+@IntegerField.register_lookup
+class IntegerGreaterThanOrEqual(IntegerFieldFloatRounding, GreaterThanOrEqual):
+    pass
+
+
+@IntegerField.register_lookup
+class IntegerLessThan(IntegerFieldFloatRounding, LessThan):
+    pass
+
+
+@Field.register_lookup
+class In(FieldGetDbPrepValueIterableMixin, BuiltinLookup):
+    lookup_name = 'in'
+
+    def process_rhs(self, compiler, connection):
+        db_rhs = getattr(self.rhs, '_db', None)
+        if db_rhs is not None and db_rhs != connection.alias:
+            raise ValueError(
+                "Subqueries aren't allowed across different databases. Force "
+                "the inner query to be evaluated using `list(inner_query)`."
+            )
+
+        if self.rhs_is_direct_value():
+            try:
+                rhs = OrderedSet(self.rhs)
+            except TypeError:  # Unhashable items in self.rhs
+                rhs = self.rhs
+
+            if not rhs:
+                raise EmptyResultSet
+
+            # rhs should be an iterable; use batch_process_rhs() to
+            # prepare/transform those values.
+            sqls, sqls_params = self.batch_process_rhs(compiler, connection, rhs)
+            placeholder = '(' + ', '.join(sqls) + ')'
+            return (placeholder, sqls_params)
+        else:
+            if not getattr(self.rhs, 'has_select_fields', True):
+                self.rhs.clear_select_clause()
+                self.rhs.add_fields(['pk'])
+            return super().process_rhs(compiler, connection)
+
+    def get_rhs_op(self, connection, rhs):
+        return 'IN %s' % rhs
+
+    def as_sql(self, compiler, connection):
+        max_in_list_size = connection.ops.max_in_list_size()
+        if self.rhs_is_direct_value() and max_in_list_size and len(self.rhs) > max_in_list_size:
+            return self.split_parameter_list_as_sql(compiler, connection)
+        return super().as_sql(compiler, connection)
+
+    def split_parameter_list_as_sql(self, compiler, connection):
+        # This is a special case for databases which limit the number of
+        # elements which can appear in an 'IN' clause.
+        max_in_list_size = connection.ops.max_in_list_size()
+        lhs, lhs_params = self.process_lhs(compiler, connection)
+        rhs, rhs_params = self.batch_process_rhs(compiler, connection)
+        in_clause_elements = ['(']
+        params = []
+        for offset in range(0, len(rhs_params), max_in_list_size):
+            if offset > 0:
+                in_clause_elements.append(' OR ')
+            in_clause_elements.append('%s IN (' % lhs)
+            params.extend(lhs_params)
+            sqls = rhs[offset: offset + max_in_list_size]
+            sqls_params = rhs_params[offset: offset + max_in_list_size]
+            param_group = ', '.join(sqls)
+            in_clause_elements.append(param_group)
+            in_clause_elements.append(')')
+            params.extend(sqls_params)
+        in_clause_elements.append(')')
+        return ''.join(in_clause_elements), params
+
+
+class PatternLookup(BuiltinLookup):
+    param_pattern = '%%%s%%'
+    prepare_rhs = False
+
+    def get_rhs_op(self, connection, rhs):
+        # Assume we are in startswith. We need to produce SQL like:
+        #     col LIKE %s, ['thevalue%']
+        # For python values we can (and should) do that directly in Python,
+        # but if the value is for example reference to other column, then
+        # we need to add the % pattern match to the lookup by something like
+        #     col LIKE othercol || '%%'
+        # So, for Python values we don't need any special pattern, but for
+        # SQL reference values or SQL transformations we need the correct
+        # pattern added.
+        if hasattr(self.rhs, 'as_sql') or self.bilateral_transforms:
+            pattern = connection.pattern_ops[self.lookup_name].format(connection.pattern_esc)
+            return pattern.format(rhs)
+        else:
+            return super().get_rhs_op(connection, rhs)
+
+    def process_rhs(self, qn, connection):
+        rhs, params = super().process_rhs(qn, connection)
+        if self.rhs_is_direct_value() and params and not self.bilateral_transforms:
+            params[0] = self.param_pattern % connection.ops.prep_for_like_query(params[0])
+        return rhs, params
+
+
+@Field.register_lookup
+class Contains(PatternLookup):
+    lookup_name = 'contains'
+
+
+@Field.register_lookup
+class IContains(Contains):
+    lookup_name = 'icontains'
+
+
+@Field.register_lookup
+class StartsWith(PatternLookup):
+    lookup_name = 'startswith'
+    param_pattern = '%s%%'
+
+
+@Field.register_lookup
+class IStartsWith(StartsWith):
+    lookup_name = 'istartswith'
+
+
+@Field.register_lookup
+class EndsWith(PatternLookup):
+    lookup_name = 'endswith'
+    param_pattern = '%%%s'
+
+
+@Field.register_lookup
+class IEndsWith(EndsWith):
+    lookup_name = 'iendswith'
+
+
+@Field.register_lookup
+class Range(FieldGetDbPrepValueIterableMixin, BuiltinLookup):
+    lookup_name = 'range'
+
+    def get_rhs_op(self, connection, rhs):
+        return "BETWEEN %s AND %s" % (rhs[0], rhs[1])
+
+
+@Field.register_lookup
+class IsNull(BuiltinLookup):
+    lookup_name = 'isnull'
+    prepare_rhs = False
+
+    def as_sql(self, compiler, connection):
+        sql, params = compiler.compile(self.lhs)
+        if self.rhs:
+            return "%s IS NULL" % sql, params
+        else:
+            return "%s IS NOT NULL" % sql, params
+
+
+@Field.register_lookup
+class Regex(BuiltinLookup):
+    lookup_name = 'regex'
+    prepare_rhs = False
+
+    def as_sql(self, compiler, connection):
+        if self.lookup_name in connection.operators:
+            return super().as_sql(compiler, connection)
+        else:
+            lhs, lhs_params = self.process_lhs(compiler, connection)
+            rhs, rhs_params = self.process_rhs(compiler, connection)
+            sql_template = connection.ops.regex_lookup(self.lookup_name)
+            return sql_template % (lhs, rhs), lhs_params + rhs_params
+
+
+@Field.register_lookup
+class IRegex(Regex):
+    lookup_name = 'iregex'
+
+
+class YearLookup(Lookup):
+    def year_lookup_bounds(self, connection, year):
+        output_field = self.lhs.lhs.output_field
+        if isinstance(output_field, DateTimeField):
+            bounds = connection.ops.year_lookup_bounds_for_datetime_field(year)
+        else:
+            bounds = connection.ops.year_lookup_bounds_for_date_field(year)
+        return bounds
+
+    def as_sql(self, compiler, connection):
+        # Avoid the extract operation if the rhs is a direct value to allow
+        # indexes to be used.
+        if self.rhs_is_direct_value():
+            # Skip the extract part by directly using the originating field,
+            # that is self.lhs.lhs.
+            lhs_sql, params = self.process_lhs(compiler, connection, self.lhs.lhs)
+            rhs_sql, _ = self.process_rhs(compiler, connection)
+            rhs_sql = self.get_direct_rhs_sql(connection, rhs_sql)
+            start, finish = self.year_lookup_bounds(connection, self.rhs)
+            params.extend(self.get_bound_params(start, finish))
+            return '%s %s' % (lhs_sql, rhs_sql), params
+        return super().as_sql(compiler, connection)
+
+    def get_direct_rhs_sql(self, connection, rhs):
+        return connection.operators[self.lookup_name] % rhs
+
+    def get_bound_params(self, start, finish):
+        raise NotImplementedError(
+            'subclasses of YearLookup must provide a get_bound_params() method'
+        )
+
+
+class YearExact(YearLookup, Exact):
+    def get_direct_rhs_sql(self, connection, rhs):
+        return 'BETWEEN %s AND %s'
+
+    def get_bound_params(self, start, finish):
+        return (start, finish)
+
+
+class YearGt(YearLookup, GreaterThan):
+    def get_bound_params(self, start, finish):
+        return (finish,)
+
+
+class YearGte(YearLookup, GreaterThanOrEqual):
+    def get_bound_params(self, start, finish):
+        return (start,)
+
+
+class YearLt(YearLookup, LessThan):
+    def get_bound_params(self, start, finish):
+        return (start,)
+
+
+class YearLte(YearLookup, LessThanOrEqual):
+    def get_bound_params(self, start, finish):
+        return (finish,)

venv/lib/python3.8/site-packages/django/db/models/manager.py

@@ -0,0 +1,201 @@
+import copy
+import inspect
+from importlib import import_module
+
+from django.db import router
+from django.db.models.query import QuerySet
+
+
+class BaseManager:
+    # To retain order, track each time a Manager instance is created.
+    creation_counter = 0
+
+    # Set to True for the 'objects' managers that are automatically created.
+    auto_created = False
+
+    #: If set to True the manager will be serialized into migrations and will
+    #: thus be available in e.g. RunPython operations.
+    use_in_migrations = False
+
+    def __new__(cls, *args, **kwargs):
+        # Capture the arguments to make returning them trivial.
+        obj = super().__new__(cls)
+        obj._constructor_args = (args, kwargs)
+        return obj
+
+    def __init__(self):
+        super().__init__()
+        self._set_creation_counter()
+        self.model = None
+        self.name = None
+        self._db = None
+        self._hints = {}
+
+    def __str__(self):
+        """Return "app_label.model_label.manager_name"."""
+        return '%s.%s' % (self.model._meta.label, self.name)
+
+    def deconstruct(self):
+        """
+        Return a 5-tuple of the form (as_manager (True), manager_class,
+        queryset_class, args, kwargs).
+
+        Raise a ValueError if the manager is dynamically generated.
+        """
+        qs_class = self._queryset_class
+        if getattr(self, '_built_with_as_manager', False):
+            # using MyQuerySet.as_manager()
+            return (
+                True,  # as_manager
+                None,  # manager_class
+                '%s.%s' % (qs_class.__module__, qs_class.__name__),  # qs_class
+                None,  # args
+                None,  # kwargs
+            )
+        else:
+            module_name = self.__module__
+            name = self.__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 manager %s in %s.\n"
+                    "Please note that you need to inherit from managers you "
+                    "dynamically generated with 'from_queryset()'."
+                    % (name, module_name)
+                )
+            return (
+                False,  # as_manager
+                '%s.%s' % (module_name, name),  # manager_class
+                None,  # qs_class
+                self._constructor_args[0],  # args
+                self._constructor_args[1],  # kwargs
+            )
+
+    def check(self, **kwargs):
+        return []
+
+    @classmethod
+    def _get_queryset_methods(cls, queryset_class):
+        def create_method(name, method):
+            def manager_method(self, *args, **kwargs):
+                return getattr(self.get_queryset(), name)(*args, **kwargs)
+            manager_method.__name__ = method.__name__
+            manager_method.__doc__ = method.__doc__
+            return manager_method
+
+        new_methods = {}
+        for name, method in inspect.getmembers(queryset_class, predicate=inspect.isfunction):
+            # Only copy missing methods.
+            if hasattr(cls, name):
+                continue
+            # Only copy public methods or methods with the attribute `queryset_only=False`.
+            queryset_only = getattr(method, 'queryset_only', None)
+            if queryset_only or (queryset_only is None and name.startswith('_')):
+                continue
+            # Copy the method onto the manager.
+            new_methods[name] = create_method(name, method)
+        return new_methods
+
+    @classmethod
+    def from_queryset(cls, queryset_class, class_name=None):
+        if class_name is None:
+            class_name = '%sFrom%s' % (cls.__name__, queryset_class.__name__)
+        return type(class_name, (cls,), {
+            '_queryset_class': queryset_class,
+            **cls._get_queryset_methods(queryset_class),
+        })
+
+    def contribute_to_class(self, model, name):
+        self.name = self.name or name
+        self.model = model
+
+        setattr(model, name, ManagerDescriptor(self))
+
+        model._meta.add_manager(self)
+
+    def _set_creation_counter(self):
+        """
+        Set the creation counter value for this instance and increment the
+        class-level copy.
+        """
+        self.creation_counter = BaseManager.creation_counter
+        BaseManager.creation_counter += 1
+
+    def db_manager(self, using=None, hints=None):
+        obj = copy.copy(self)
+        obj._db = using or self._db
+        obj._hints = hints or self._hints
+        return obj
+
+    @property
+    def db(self):
+        return self._db or router.db_for_read(self.model, **self._hints)
+
+    #######################
+    # PROXIES TO QUERYSET #
+    #######################
+
+    def get_queryset(self):
+        """
+        Return a new QuerySet object. Subclasses can override this method to
+        customize the behavior of the Manager.
+        """
+        return self._queryset_class(model=self.model, using=self._db, hints=self._hints)
+
+    def all(self):
+        # We can't proxy this method through the `QuerySet` like we do for the
+        # rest of the `QuerySet` methods. This is because `QuerySet.all()`
+        # works by creating a "copy" of the current queryset and in making said
+        # copy, all the cached `prefetch_related` lookups are lost. See the
+        # implementation of `RelatedManager.get_queryset()` for a better
+        # understanding of how this comes into play.
+        return self.get_queryset()
+
+    def __eq__(self, other):
+        return (
+            isinstance(other, self.__class__) and
+            self._constructor_args == other._constructor_args
+        )
+
+    def __hash__(self):
+        return id(self)
+
+
+class Manager(BaseManager.from_queryset(QuerySet)):
+    pass
+
+
+class ManagerDescriptor:
+
+    def __init__(self, manager):
+        self.manager = manager
+
+    def __get__(self, instance, cls=None):
+        if instance is not None:
+            raise AttributeError("Manager isn't accessible via %s instances" % cls.__name__)
+
+        if cls._meta.abstract:
+            raise AttributeError("Manager isn't available; %s is abstract" % (
+                cls._meta.object_name,
+            ))
+
+        if cls._meta.swapped:
+            raise AttributeError(
+                "Manager isn't available; '%s.%s' has been swapped for '%s'" % (
+                    cls._meta.app_label,
+                    cls._meta.object_name,
+                    cls._meta.swapped,
+                )
+            )
+
+        return cls._meta.managers_map[self.manager.name]
+
+
+class EmptyManager(Manager):
+    def __init__(self, model):
+        super().__init__()
+        self.model = model
+
+    def get_queryset(self):
+        return super().get_queryset().none()

venv/lib/python3.8/site-packages/django/db/models/options.py

@@ -0,0 +1,855 @@
+import copy
+import inspect
+from bisect import bisect
+from collections import defaultdict
+
+from django.apps import apps
+from django.conf import settings
+from django.core.exceptions import FieldDoesNotExist, ImproperlyConfigured
+from django.db import connections
+from django.db.models import Manager
+from django.db.models.fields import AutoField
+from django.db.models.fields.proxy import OrderWrt
+from django.db.models.query_utils import PathInfo
+from django.utils.datastructures import ImmutableList, OrderedSet
+from django.utils.functional import cached_property
+from django.utils.text import camel_case_to_spaces, format_lazy
+from django.utils.translation import override
+
+PROXY_PARENTS = object()
+
+EMPTY_RELATION_TREE = ()
+
+IMMUTABLE_WARNING = (
+    "The return type of '%s' should never be mutated. If you want to manipulate this list "
+    "for your own use, make a copy first."
+)
+
+DEFAULT_NAMES = (
+    'verbose_name', 'verbose_name_plural', 'db_table', 'ordering',
+    'unique_together', 'permissions', 'get_latest_by', 'order_with_respect_to',
+    'app_label', 'db_tablespace', 'abstract', 'managed', 'proxy', 'swappable',
+    'auto_created', 'index_together', 'apps', 'default_permissions',
+    'select_on_save', 'default_related_name', 'required_db_features',
+    'required_db_vendor', 'base_manager_name', 'default_manager_name',
+    'indexes', 'constraints',
+)
+
+
+def normalize_together(option_together):
+    """
+    option_together can be either a tuple of tuples, or a single
+    tuple of two strings. Normalize it to a tuple of tuples, so that
+    calling code can uniformly expect that.
+    """
+    try:
+        if not option_together:
+            return ()
+        if not isinstance(option_together, (tuple, list)):
+            raise TypeError
+        first_element = option_together[0]
+        if not isinstance(first_element, (tuple, list)):
+            option_together = (option_together,)
+        # Normalize everything to tuples
+        return tuple(tuple(ot) for ot in option_together)
+    except TypeError:
+        # If the value of option_together isn't valid, return it
+        # verbatim; this will be picked up by the check framework later.
+        return option_together
+
+
+def make_immutable_fields_list(name, data):
+    return ImmutableList(data, warning=IMMUTABLE_WARNING % name)
+
+
+class Options:
+    FORWARD_PROPERTIES = {
+        'fields', 'many_to_many', 'concrete_fields', 'local_concrete_fields',
+        '_forward_fields_map', 'managers', 'managers_map', 'base_manager',
+        'default_manager',
+    }
+    REVERSE_PROPERTIES = {'related_objects', 'fields_map', '_relation_tree'}
+
+    default_apps = apps
+
+    def __init__(self, meta, app_label=None):
+        self._get_fields_cache = {}
+        self.local_fields = []
+        self.local_many_to_many = []
+        self.private_fields = []
+        self.local_managers = []
+        self.base_manager_name = None
+        self.default_manager_name = None
+        self.model_name = None
+        self.verbose_name = None
+        self.verbose_name_plural = None
+        self.db_table = ''
+        self.ordering = []
+        self._ordering_clash = False
+        self.indexes = []
+        self.constraints = []
+        self.unique_together = []
+        self.index_together = []
+        self.select_on_save = False
+        self.default_permissions = ('add', 'change', 'delete', 'view')
+        self.permissions = []
+        self.object_name = None
+        self.app_label = app_label
+        self.get_latest_by = None
+        self.order_with_respect_to = None
+        self.db_tablespace = settings.DEFAULT_TABLESPACE
+        self.required_db_features = []
+        self.required_db_vendor = None
+        self.meta = meta
+        self.pk = None
+        self.auto_field = None
+        self.abstract = False
+        self.managed = True
+        self.proxy = False
+        # For any class that is a proxy (including automatically created
+        # classes for deferred object loading), proxy_for_model tells us
+        # which class this model is proxying. Note that proxy_for_model
+        # can create a chain of proxy models. For non-proxy models, the
+        # variable is always None.
+        self.proxy_for_model = None
+        # For any non-abstract class, the concrete class is the model
+        # in the end of the proxy_for_model chain. In particular, for
+        # concrete models, the concrete_model is always the class itself.
+        self.concrete_model = None
+        self.swappable = None
+        self.parents = {}
+        self.auto_created = False
+
+        # List of all lookups defined in ForeignKey 'limit_choices_to' options
+        # from *other* models. Needed for some admin checks. Internal use only.
+        self.related_fkey_lookups = []
+
+        # A custom app registry to use, if you're making a separate model set.
+        self.apps = self.default_apps
+
+        self.default_related_name = None
+
+    @property
+    def label(self):
+        return '%s.%s' % (self.app_label, self.object_name)
+
+    @property
+    def label_lower(self):
+        return '%s.%s' % (self.app_label, self.model_name)
+
+    @property
+    def app_config(self):
+        # Don't go through get_app_config to avoid triggering imports.
+        return self.apps.app_configs.get(self.app_label)
+
+    @property
+    def installed(self):
+        return self.app_config is not None
+
+    def contribute_to_class(self, cls, name):
+        from django.db import connection
+        from django.db.backends.utils import truncate_name
+
+        cls._meta = self
+        self.model = cls
+        # First, construct the default values for these options.
+        self.object_name = cls.__name__
+        self.model_name = self.object_name.lower()
+        self.verbose_name = camel_case_to_spaces(self.object_name)
+
+        # Store the original user-defined values for each option,
+        # for use when serializing the model definition
+        self.original_attrs = {}
+
+        # Next, apply any overridden values from 'class Meta'.
+        if self.meta:
+            meta_attrs = self.meta.__dict__.copy()
+            for name in self.meta.__dict__:
+                # Ignore any private attributes that Django doesn't care about.
+                # NOTE: We can't modify a dictionary's contents while looping
+                # over it, so we loop over the *original* dictionary instead.
+                if name.startswith('_'):
+                    del meta_attrs[name]
+            for attr_name in DEFAULT_NAMES:
+                if attr_name in meta_attrs:
+                    setattr(self, attr_name, meta_attrs.pop(attr_name))
+                    self.original_attrs[attr_name] = getattr(self, attr_name)
+                elif hasattr(self.meta, attr_name):
+                    setattr(self, attr_name, getattr(self.meta, attr_name))
+                    self.original_attrs[attr_name] = getattr(self, attr_name)
+
+            self.unique_together = normalize_together(self.unique_together)
+            self.index_together = normalize_together(self.index_together)
+            # App label/class name interpolation for names of constraints and
+            # indexes.
+            if not getattr(cls._meta, 'abstract', False):
+                for attr_name in {'constraints', 'indexes'}:
+                    objs = getattr(self, attr_name, [])
+                    setattr(self, attr_name, self._format_names_with_class(cls, objs))
+
+            # verbose_name_plural is a special case because it uses a 's'
+            # by default.
+            if self.verbose_name_plural is None:
+                self.verbose_name_plural = format_lazy('{}s', self.verbose_name)
+
+            # order_with_respect_and ordering are mutually exclusive.
+            self._ordering_clash = bool(self.ordering and self.order_with_respect_to)
+
+            # Any leftover attributes must be invalid.
+            if meta_attrs != {}:
+                raise TypeError("'class Meta' got invalid attribute(s): %s" % ','.join(meta_attrs))
+        else:
+            self.verbose_name_plural = format_lazy('{}s', self.verbose_name)
+        del self.meta
+
+        # If the db_table wasn't provided, use the app_label + model_name.
+        if not self.db_table:
+            self.db_table = "%s_%s" % (self.app_label, self.model_name)
+            self.db_table = truncate_name(self.db_table, connection.ops.max_name_length())
+
+    def _format_names_with_class(self, cls, objs):
+        """App label/class name interpolation for object names."""
+        new_objs = []
+        for obj in objs:
+            obj = obj.clone()
+            obj.name = obj.name % {
+                'app_label': cls._meta.app_label.lower(),
+                'class': cls.__name__.lower(),
+            }
+            new_objs.append(obj)
+        return new_objs
+
+    def _prepare(self, model):
+        if self.order_with_respect_to:
+            # The app registry will not be ready at this point, so we cannot
+            # use get_field().
+            query = self.order_with_respect_to
+            try:
+                self.order_with_respect_to = next(
+                    f for f in self._get_fields(reverse=False)
+                    if f.name == query or f.attname == query
+                )
+            except StopIteration:
+                raise FieldDoesNotExist("%s has no field named '%s'" % (self.object_name, query))
+
+            self.ordering = ('_order',)
+            if not any(isinstance(field, OrderWrt) for field in model._meta.local_fields):
+                model.add_to_class('_order', OrderWrt())
+        else:
+            self.order_with_respect_to = None
+
+        if self.pk is None:
+            if self.parents:
+                # Promote the first parent link in lieu of adding yet another
+                # field.
+                field = next(iter(self.parents.values()))
+                # Look for a local field with the same name as the
+                # first parent link. If a local field has already been
+                # created, use it instead of promoting the parent
+                already_created = [fld for fld in self.local_fields if fld.name == field.name]
+                if already_created:
+                    field = already_created[0]
+                field.primary_key = True
+                self.setup_pk(field)
+                if not field.remote_field.parent_link:
+                    raise ImproperlyConfigured(
+                        'Add parent_link=True to %s.' % field,
+                    )
+            else:
+                auto = AutoField(verbose_name='ID', primary_key=True, auto_created=True)
+                model.add_to_class('id', auto)
+
+    def add_manager(self, manager):
+        self.local_managers.append(manager)
+        self._expire_cache()
+
+    def add_field(self, field, private=False):
+        # Insert the given field in the order in which it was created, using
+        # the "creation_counter" attribute of the field.
+        # Move many-to-many related fields from self.fields into
+        # self.many_to_many.
+        if private:
+            self.private_fields.append(field)
+        elif field.is_relation and field.many_to_many:
+            self.local_many_to_many.insert(bisect(self.local_many_to_many, field), field)
+        else:
+            self.local_fields.insert(bisect(self.local_fields, field), field)
+            self.setup_pk(field)
+
+        # If the field being added is a relation to another known field,
+        # expire the cache on this field and the forward cache on the field
+        # being referenced, because there will be new relationships in the
+        # cache. Otherwise, expire the cache of references *to* this field.
+        # The mechanism for getting at the related model is slightly odd -
+        # ideally, we'd just ask for field.related_model. However, related_model
+        # is a cached property, and all the models haven't been loaded yet, so
+        # we need to make sure we don't cache a string reference.
+        if field.is_relation and hasattr(field.remote_field, 'model') and field.remote_field.model:
+            try:
+                field.remote_field.model._meta._expire_cache(forward=False)
+            except AttributeError:
+                pass
+            self._expire_cache()
+        else:
+            self._expire_cache(reverse=False)
+
+    def setup_pk(self, field):
+        if not self.pk and field.primary_key:
+            self.pk = field
+            field.serialize = False
+
+    def setup_proxy(self, target):
+        """
+        Do the internal setup so that the current model is a proxy for
+        "target".
+        """
+        self.pk = target._meta.pk
+        self.proxy_for_model = target
+        self.db_table = target._meta.db_table
+
+    def __repr__(self):
+        return '<Options for %s>' % self.object_name
+
+    def __str__(self):
+        return "%s.%s" % (self.app_label, self.model_name)
+
+    def can_migrate(self, connection):
+        """
+        Return True if the model can/should be migrated on the `connection`.
+        `connection` can be either a real connection or a connection alias.
+        """
+        if self.proxy or self.swapped or not self.managed:
+            return False
+        if isinstance(connection, str):
+            connection = connections[connection]
+        if self.required_db_vendor:
+            return self.required_db_vendor == connection.vendor
+        if self.required_db_features:
+            return all(getattr(connection.features, feat, False)
+                       for feat in self.required_db_features)
+        return True
+
+    @property
+    def verbose_name_raw(self):
+        """Return the untranslated verbose name."""
+        with override(None):
+            return str(self.verbose_name)
+
+    @property
+    def swapped(self):
+        """
+        Has this model been swapped out for another? If so, return the model
+        name of the replacement; otherwise, return None.
+
+        For historical reasons, model name lookups using get_model() are
+        case insensitive, so we make sure we are case insensitive here.
+        """
+        if self.swappable:
+            swapped_for = getattr(settings, self.swappable, None)
+            if swapped_for:
+                try:
+                    swapped_label, swapped_object = swapped_for.split('.')
+                except ValueError:
+                    # setting not in the format app_label.model_name
+                    # raising ImproperlyConfigured here causes problems with
+                    # test cleanup code - instead it is raised in get_user_model
+                    # or as part of validation.
+                    return swapped_for
+
+                if '%s.%s' % (swapped_label, swapped_object.lower()) != self.label_lower:
+                    return swapped_for
+        return None
+
+    @cached_property
+    def managers(self):
+        managers = []
+        seen_managers = set()
+        bases = (b for b in self.model.mro() if hasattr(b, '_meta'))
+        for depth, base in enumerate(bases):
+            for manager in base._meta.local_managers:
+                if manager.name in seen_managers:
+                    continue
+
+                manager = copy.copy(manager)
+                manager.model = self.model
+                seen_managers.add(manager.name)
+                managers.append((depth, manager.creation_counter, manager))
+
+        return make_immutable_fields_list(
+            "managers",
+            (m[2] for m in sorted(managers)),
+        )
+
+    @cached_property
+    def managers_map(self):
+        return {manager.name: manager for manager in self.managers}
+
+    @cached_property
+    def base_manager(self):
+        base_manager_name = self.base_manager_name
+        if not base_manager_name:
+            # Get the first parent's base_manager_name if there's one.
+            for parent in self.model.mro()[1:]:
+                if hasattr(parent, '_meta'):
+                    if parent._base_manager.name != '_base_manager':
+                        base_manager_name = parent._base_manager.name
+                    break
+
+        if base_manager_name:
+            try:
+                return self.managers_map[base_manager_name]
+            except KeyError:
+                raise ValueError(
+                    "%s has no manager named %r" % (
+                        self.object_name,
+                        base_manager_name,
+                    )
+                )
+
+        manager = Manager()
+        manager.name = '_base_manager'
+        manager.model = self.model
+        manager.auto_created = True
+        return manager
+
+    @cached_property
+    def default_manager(self):
+        default_manager_name = self.default_manager_name
+        if not default_manager_name and not self.local_managers:
+            # Get the first parent's default_manager_name if there's one.
+            for parent in self.model.mro()[1:]:
+                if hasattr(parent, '_meta'):
+                    default_manager_name = parent._meta.default_manager_name
+                    break
+
+        if default_manager_name:
+            try:
+                return self.managers_map[default_manager_name]
+            except KeyError:
+                raise ValueError(
+                    "%s has no manager named %r" % (
+                        self.object_name,
+                        default_manager_name,
+                    )
+                )
+
+        if self.managers:
+            return self.managers[0]
+
+    @cached_property
+    def fields(self):
+        """
+        Return a list of all forward fields on the model and its parents,
+        excluding ManyToManyFields.
+
+        Private API intended only to be used by Django itself; get_fields()
+        combined with filtering of field properties is the public API for
+        obtaining this field list.
+        """
+        # For legacy reasons, the fields property should only contain forward
+        # fields that are not private or with a m2m cardinality. Therefore we
+        # pass these three filters as filters to the generator.
+        # The third lambda is a longwinded way of checking f.related_model - we don't
+        # use that property directly because related_model is a cached property,
+        # and all the models may not have been loaded yet; we don't want to cache
+        # the string reference to the related_model.
+        def is_not_an_m2m_field(f):
+            return not (f.is_relation and f.many_to_many)
+
+        def is_not_a_generic_relation(f):
+            return not (f.is_relation and f.one_to_many)
+
+        def is_not_a_generic_foreign_key(f):
+            return not (
+                f.is_relation and f.many_to_one and not (hasattr(f.remote_field, 'model') and f.remote_field.model)
+            )
+
+        return make_immutable_fields_list(
+            "fields",
+            (f for f in self._get_fields(reverse=False)
+             if is_not_an_m2m_field(f) and is_not_a_generic_relation(f) and is_not_a_generic_foreign_key(f))
+        )
+
+    @cached_property
+    def concrete_fields(self):
+        """
+        Return a list of all concrete fields on the model and its parents.
+
+        Private API intended only to be used by Django itself; get_fields()
+        combined with filtering of field properties is the public API for
+        obtaining this field list.
+        """
+        return make_immutable_fields_list(
+            "concrete_fields", (f for f in self.fields if f.concrete)
+        )
+
+    @cached_property
+    def local_concrete_fields(self):
+        """
+        Return a list of all concrete fields on the model.
+
+        Private API intended only to be used by Django itself; get_fields()
+        combined with filtering of field properties is the public API for
+        obtaining this field list.
+        """
+        return make_immutable_fields_list(
+            "local_concrete_fields", (f for f in self.local_fields if f.concrete)
+        )
+
+    @cached_property
+    def many_to_many(self):
+        """
+        Return a list of all many to many fields on the model and its parents.
+
+        Private API intended only to be used by Django itself; get_fields()
+        combined with filtering of field properties is the public API for
+        obtaining this list.
+        """
+        return make_immutable_fields_list(
+            "many_to_many",
+            (f for f in self._get_fields(reverse=False) if f.is_relation and f.many_to_many)
+        )
+
+    @cached_property
+    def related_objects(self):
+        """
+        Return all related objects pointing to the current model. The related
+        objects can come from a one-to-one, one-to-many, or many-to-many field
+        relation type.
+
+        Private API intended only to be used by Django itself; get_fields()
+        combined with filtering of field properties is the public API for
+        obtaining this field list.
+        """
+        all_related_fields = self._get_fields(forward=False, reverse=True, include_hidden=True)
+        return make_immutable_fields_list(
+            "related_objects",
+            (obj for obj in all_related_fields if not obj.hidden or obj.field.many_to_many)
+        )
+
+    @cached_property
+    def _forward_fields_map(self):
+        res = {}
+        fields = self._get_fields(reverse=False)
+        for field in fields:
+            res[field.name] = field
+            # Due to the way Django's internals work, get_field() should also
+            # be able to fetch a field by attname. In the case of a concrete
+            # field with relation, includes the *_id name too
+            try:
+                res[field.attname] = field
+            except AttributeError:
+                pass
+        return res
+
+    @cached_property
+    def fields_map(self):
+        res = {}
+        fields = self._get_fields(forward=False, include_hidden=True)
+        for field in fields:
+            res[field.name] = field
+            # Due to the way Django's internals work, get_field() should also
+            # be able to fetch a field by attname. In the case of a concrete
+            # field with relation, includes the *_id name too
+            try:
+                res[field.attname] = field
+            except AttributeError:
+                pass
+        return res
+
+    def get_field(self, field_name):
+        """
+        Return a field instance given the name of a forward or reverse field.
+        """
+        try:
+            # In order to avoid premature loading of the relation tree
+            # (expensive) we prefer checking if the field is a forward field.
+            return self._forward_fields_map[field_name]
+        except KeyError:
+            # If the app registry is not ready, reverse fields are
+            # unavailable, therefore we throw a FieldDoesNotExist exception.
+            if not self.apps.models_ready:
+                raise FieldDoesNotExist(
+                    "%s has no field named '%s'. The app cache isn't ready yet, "
+                    "so if this is an auto-created related field, it won't "
+                    "be available yet." % (self.object_name, field_name)
+                )
+
+        try:
+            # Retrieve field instance by name from cached or just-computed
+            # field map.
+            return self.fields_map[field_name]
+        except KeyError:
+            raise FieldDoesNotExist("%s has no field named '%s'" % (self.object_name, field_name))
+
+    def get_base_chain(self, model):
+        """
+        Return a list of parent classes leading to `model` (ordered from
+        closest to most distant ancestor). This has to handle the case where
+        `model` is a grandparent or even more distant relation.
+        """
+        if not self.parents:
+            return []
+        if model in self.parents:
+            return [model]
+        for parent in self.parents:
+            res = parent._meta.get_base_chain(model)
+            if res:
+                res.insert(0, parent)
+                return res
+        return []
+
+    def get_parent_list(self):
+        """
+        Return all the ancestors of this model as a list ordered by MRO.
+        Useful for determining if something is an ancestor, regardless of lineage.
+        """
+        result = OrderedSet(self.parents)
+        for parent in self.parents:
+            for ancestor in parent._meta.get_parent_list():
+                result.add(ancestor)
+        return list(result)
+
+    def get_ancestor_link(self, ancestor):
+        """
+        Return the field on the current model which points to the given
+        "ancestor". This is possible an indirect link (a pointer to a parent
+        model, which points, eventually, to the ancestor). Used when
+        constructing table joins for model inheritance.
+
+        Return None if the model isn't an ancestor of this one.
+        """
+        if ancestor in self.parents:
+            return self.parents[ancestor]
+        for parent in self.parents:
+            # Tries to get a link field from the immediate parent
+            parent_link = parent._meta.get_ancestor_link(ancestor)
+            if parent_link:
+                # In case of a proxied model, the first link
+                # of the chain to the ancestor is that parent
+                # links
+                return self.parents[parent] or parent_link
+
+    def get_path_to_parent(self, parent):
+        """
+        Return a list of PathInfos containing the path from the current
+        model to the parent model, or an empty list if parent is not a
+        parent of the current model.
+        """
+        if self.model is parent:
+            return []
+        # Skip the chain of proxy to the concrete proxied model.
+        proxied_model = self.concrete_model
+        path = []
+        opts = self
+        for int_model in self.get_base_chain(parent):
+            if int_model is proxied_model:
+                opts = int_model._meta
+            else:
+                final_field = opts.parents[int_model]
+                targets = (final_field.remote_field.get_related_field(),)
+                opts = int_model._meta
+                path.append(PathInfo(
+                    from_opts=final_field.model._meta,
+                    to_opts=opts,
+                    target_fields=targets,
+                    join_field=final_field,
+                    m2m=False,
+                    direct=True,
+                    filtered_relation=None,
+                ))
+        return path
+
+    def get_path_from_parent(self, parent):
+        """
+        Return a list of PathInfos containing the path from the parent
+        model to the current model, or an empty list if parent is not a
+        parent of the current model.
+        """
+        if self.model is parent:
+            return []
+        model = self.concrete_model
+        # Get a reversed base chain including both the current and parent
+        # models.
+        chain = model._meta.get_base_chain(parent)
+        chain.reverse()
+        chain.append(model)
+        # Construct a list of the PathInfos between models in chain.
+        path = []
+        for i, ancestor in enumerate(chain[:-1]):
+            child = chain[i + 1]
+            link = child._meta.get_ancestor_link(ancestor)
+            path.extend(link.get_reverse_path_info())
+        return path
+
+    def _populate_directed_relation_graph(self):
+        """
+        This method is used by each model to find its reverse objects. As this
+        method is very expensive and is accessed frequently (it looks up every
+        field in a model, in every app), it is computed on first access and then
+        is set as a property on every model.
+        """
+        related_objects_graph = defaultdict(list)
+
+        all_models = self.apps.get_models(include_auto_created=True)
+        for model in all_models:
+            opts = model._meta
+            # Abstract model's fields are copied to child models, hence we will
+            # see the fields from the child models.
+            if opts.abstract:
+                continue
+            fields_with_relations = (
+                f for f in opts._get_fields(reverse=False, include_parents=False)
+                if f.is_relation and f.related_model is not None
+            )
+            for f in fields_with_relations:
+                if not isinstance(f.remote_field.model, str):
+                    related_objects_graph[f.remote_field.model._meta.concrete_model._meta].append(f)
+
+        for model in all_models:
+            # Set the relation_tree using the internal __dict__. In this way
+            # we avoid calling the cached property. In attribute lookup,
+            # __dict__ takes precedence over a data descriptor (such as
+            # @cached_property). This means that the _meta._relation_tree is
+            # only called if related_objects is not in __dict__.
+            related_objects = related_objects_graph[model._meta.concrete_model._meta]
+            model._meta.__dict__['_relation_tree'] = related_objects
+        # It seems it is possible that self is not in all_models, so guard
+        # against that with default for get().
+        return self.__dict__.get('_relation_tree', EMPTY_RELATION_TREE)
+
+    @cached_property
+    def _relation_tree(self):
+        return self._populate_directed_relation_graph()
+
+    def _expire_cache(self, forward=True, reverse=True):
+        # This method is usually called by apps.cache_clear(), when the
+        # registry is finalized, or when a new field is added.
+        if forward:
+            for cache_key in self.FORWARD_PROPERTIES:
+                if cache_key in self.__dict__:
+                    delattr(self, cache_key)
+        if reverse and not self.abstract:
+            for cache_key in self.REVERSE_PROPERTIES:
+                if cache_key in self.__dict__:
+                    delattr(self, cache_key)
+        self._get_fields_cache = {}
+
+    def get_fields(self, include_parents=True, include_hidden=False):
+        """
+        Return a list of fields associated to the model. By default, include
+        forward and reverse fields, fields derived from inheritance, but not
+        hidden fields. The returned fields can be changed using the parameters:
+
+        - include_parents: include fields derived from inheritance
+        - include_hidden:  include fields that have a related_name that
+                           starts with a "+"
+        """
+        if include_parents is False:
+            include_parents = PROXY_PARENTS
+        return self._get_fields(include_parents=include_parents, include_hidden=include_hidden)
+
+    def _get_fields(self, forward=True, reverse=True, include_parents=True, include_hidden=False,
+                    seen_models=None):
+        """
+        Internal helper function to return fields of the model.
+        * If forward=True, then fields defined on this model are returned.
+        * If reverse=True, then relations pointing to this model are returned.
+        * If include_hidden=True, then fields with is_hidden=True are returned.
+        * The include_parents argument toggles if fields from parent models
+          should be included. It has three values: True, False, and
+          PROXY_PARENTS. When set to PROXY_PARENTS, the call will return all
+          fields defined for the current model or any of its parents in the
+          parent chain to the model's concrete model.
+        """
+        if include_parents not in (True, False, PROXY_PARENTS):
+            raise TypeError("Invalid argument for include_parents: %s" % (include_parents,))
+        # This helper function is used to allow recursion in ``get_fields()``
+        # implementation and to provide a fast way for Django's internals to
+        # access specific subsets of fields.
+
+        # We must keep track of which models we have already seen. Otherwise we
+        # could include the same field multiple times from different models.
+        topmost_call = seen_models is None
+        if topmost_call:
+            seen_models = set()
+        seen_models.add(self.model)
+
+        # Creates a cache key composed of all arguments
+        cache_key = (forward, reverse, include_parents, include_hidden, topmost_call)
+
+        try:
+            # In order to avoid list manipulation. Always return a shallow copy
+            # of the results.
+            return self._get_fields_cache[cache_key]
+        except KeyError:
+            pass
+
+        fields = []
+        # Recursively call _get_fields() on each parent, with the same
+        # options provided in this call.
+        if include_parents is not False:
+            for parent in self.parents:
+                # In diamond inheritance it is possible that we see the same
+                # model from two different routes. In that case, avoid adding
+                # fields from the same parent again.
+                if parent in seen_models:
+                    continue
+                if (parent._meta.concrete_model != self.concrete_model and
+                        include_parents == PROXY_PARENTS):
+                    continue
+                for obj in parent._meta._get_fields(
+                        forward=forward, reverse=reverse, include_parents=include_parents,
+                        include_hidden=include_hidden, seen_models=seen_models):
+                    if not getattr(obj, 'parent_link', False) or obj.model == self.concrete_model:
+                        fields.append(obj)
+        if reverse and not self.proxy:
+            # Tree is computed once and cached until the app cache is expired.
+            # It is composed of a list of fields pointing to the current model
+            # from other models.
+            all_fields = self._relation_tree
+            for field in all_fields:
+                # If hidden fields should be included or the relation is not
+                # intentionally hidden, add to the fields dict.
+                if include_hidden or not field.remote_field.hidden:
+                    fields.append(field.remote_field)
+
+        if forward:
+            fields += self.local_fields
+            fields += self.local_many_to_many
+            # Private fields are recopied to each child model, and they get a
+            # different model as field.model in each child. Hence we have to
+            # add the private fields separately from the topmost call. If we
+            # did this recursively similar to local_fields, we would get field
+            # instances with field.model != self.model.
+            if topmost_call:
+                fields += self.private_fields
+
+        # In order to avoid list manipulation. Always
+        # return a shallow copy of the results
+        fields = make_immutable_fields_list("get_fields()", fields)
+
+        # Store result into cache for later access
+        self._get_fields_cache[cache_key] = fields
+        return fields
+
+    @cached_property
+    def _property_names(self):
+        """Return a set of the names of the properties defined on the model."""
+        names = []
+        for name in dir(self.model):
+            attr = inspect.getattr_static(self.model, name)
+            if isinstance(attr, property):
+                names.append(name)
+        return frozenset(names)
+
+    @cached_property
+    def db_returning_fields(self):
+        """
+        Private API intended only to be used by Django itself.
+        Fields to be returned after a database insert.
+        """
+        return [
+            field for field in self._get_fields(forward=True, reverse=False, include_parents=PROXY_PARENTS)
+            if getattr(field, 'db_returning', False)
+        ]

venv/lib/python3.8/site-packages/django/db/models/query_utils.py

@@ -0,0 +1,339 @@
+"""
+Various data structures used in query construction.
+
+Factored out from django.db.models.query to avoid making the main module very
+large and/or so that they can be used by other modules without getting into
+circular import difficulties.
+"""
+import copy
+import functools
+import inspect
+from collections import namedtuple
+
+from django.db.models.constants import LOOKUP_SEP
+from django.utils import tree
+
+# PathInfo is used when converting lookups (fk__somecol). The contents
+# describe the relation in Model terms (model Options and Fields for both
+# sides of the relation. The join_field is the field backing the relation.
+PathInfo = namedtuple('PathInfo', 'from_opts to_opts target_fields join_field m2m direct filtered_relation')
+
+
+class InvalidQuery(Exception):
+    """The query passed to raw() isn't a safe query to use with raw()."""
+    pass
+
+
+def subclasses(cls):
+    yield cls
+    for subclass in cls.__subclasses__():
+        yield from subclasses(subclass)
+
+
+class QueryWrapper:
+    """
+    A type that indicates the contents are an SQL fragment and the associate
+    parameters. Can be used to pass opaque data to a where-clause, for example.
+    """
+    contains_aggregate = False
+
+    def __init__(self, sql, params):
+        self.data = sql, list(params)
+
+    def as_sql(self, compiler=None, connection=None):
+        return self.data
+
+
+class Q(tree.Node):
+    """
+    Encapsulate filters as objects that can then be combined logically (using
+    `&` and `|`).
+    """
+    # Connection types
+    AND = 'AND'
+    OR = 'OR'
+    default = AND
+    conditional = True
+
+    def __init__(self, *args, _connector=None, _negated=False, **kwargs):
+        super().__init__(children=[*args, *sorted(kwargs.items())], connector=_connector, negated=_negated)
+
+    def _combine(self, other, conn):
+        if not isinstance(other, Q):
+            raise TypeError(other)
+
+        # If the other Q() is empty, ignore it and just use `self`.
+        if not other:
+            return copy.deepcopy(self)
+        # Or if this Q is empty, ignore it and just use `other`.
+        elif not self:
+            return copy.deepcopy(other)
+
+        obj = type(self)()
+        obj.connector = conn
+        obj.add(self, conn)
+        obj.add(other, conn)
+        return obj
+
+    def __or__(self, other):
+        return self._combine(other, self.OR)
+
+    def __and__(self, other):
+        return self._combine(other, self.AND)
+
+    def __invert__(self):
+        obj = type(self)()
+        obj.add(self, self.AND)
+        obj.negate()
+        return obj
+
+    def resolve_expression(self, query=None, allow_joins=True, reuse=None, summarize=False, for_save=False):
+        # We must promote any new joins to left outer joins so that when Q is
+        # used as an expression, rows aren't filtered due to joins.
+        clause, joins = query._add_q(
+            self, reuse, allow_joins=allow_joins, split_subq=False,
+            check_filterable=False,
+        )
+        query.promote_joins(joins)
+        return clause
+
+    def deconstruct(self):
+        path = '%s.%s' % (self.__class__.__module__, self.__class__.__name__)
+        if path.startswith('django.db.models.query_utils'):
+            path = path.replace('django.db.models.query_utils', 'django.db.models')
+        args, kwargs = (), {}
+        if len(self.children) == 1 and not isinstance(self.children[0], Q):
+            child = self.children[0]
+            kwargs = {child[0]: child[1]}
+        else:
+            args = tuple(self.children)
+            if self.connector != self.default:
+                kwargs = {'_connector': self.connector}
+        if self.negated:
+            kwargs['_negated'] = True
+        return path, args, kwargs
+
+
+class DeferredAttribute:
+    """
+    A wrapper for a deferred-loading field. When the value is read from this
+    object the first time, the query is executed.
+    """
+    def __init__(self, field):
+        self.field = field
+
+    def __get__(self, instance, cls=None):
+        """
+        Retrieve and caches the value from the datastore on the first lookup.
+        Return the cached value.
+        """
+        if instance is None:
+            return self
+        data = instance.__dict__
+        field_name = self.field.attname
+        if data.get(field_name, self) is self:
+            # Let's see if the field is part of the parent chain. If so we
+            # might be able to reuse the already loaded value. Refs #18343.
+            val = self._check_parent_chain(instance)
+            if val is None:
+                instance.refresh_from_db(fields=[field_name])
+                val = getattr(instance, field_name)
+            data[field_name] = val
+        return data[field_name]
+
+    def _check_parent_chain(self, instance):
+        """
+        Check if the field value can be fetched from a parent field already
+        loaded in the instance. This can be done if the to-be fetched
+        field is a primary key field.
+        """
+        opts = instance._meta
+        link_field = opts.get_ancestor_link(self.field.model)
+        if self.field.primary_key and self.field != link_field:
+            return getattr(instance, link_field.attname)
+        return None
+
+
+class RegisterLookupMixin:
+
+    @classmethod
+    def _get_lookup(cls, lookup_name):
+        return cls.get_lookups().get(lookup_name, None)
+
+    @classmethod
+    @functools.lru_cache(maxsize=None)
+    def get_lookups(cls):
+        class_lookups = [parent.__dict__.get('class_lookups', {}) for parent in inspect.getmro(cls)]
+        return cls.merge_dicts(class_lookups)
+
+    def get_lookup(self, lookup_name):
+        from django.db.models.lookups import Lookup
+        found = self._get_lookup(lookup_name)
+        if found is None and hasattr(self, 'output_field'):
+            return self.output_field.get_lookup(lookup_name)
+        if found is not None and not issubclass(found, Lookup):
+            return None
+        return found
+
+    def get_transform(self, lookup_name):
+        from django.db.models.lookups import Transform
+        found = self._get_lookup(lookup_name)
+        if found is None and hasattr(self, 'output_field'):
+            return self.output_field.get_transform(lookup_name)
+        if found is not None and not issubclass(found, Transform):
+            return None
+        return found
+
+    @staticmethod
+    def merge_dicts(dicts):
+        """
+        Merge dicts in reverse to preference the order of the original list. e.g.,
+        merge_dicts([a, b]) will preference the keys in 'a' over those in 'b'.
+        """
+        merged = {}
+        for d in reversed(dicts):
+            merged.update(d)
+        return merged
+
+    @classmethod
+    def _clear_cached_lookups(cls):
+        for subclass in subclasses(cls):
+            subclass.get_lookups.cache_clear()
+
+    @classmethod
+    def register_lookup(cls, lookup, lookup_name=None):
+        if lookup_name is None:
+            lookup_name = lookup.lookup_name
+        if 'class_lookups' not in cls.__dict__:
+            cls.class_lookups = {}
+        cls.class_lookups[lookup_name] = lookup
+        cls._clear_cached_lookups()
+        return lookup
+
+    @classmethod
+    def _unregister_lookup(cls, lookup, lookup_name=None):
+        """
+        Remove given lookup from cls lookups. For use in tests only as it's
+        not thread-safe.
+        """
+        if lookup_name is None:
+            lookup_name = lookup.lookup_name
+        del cls.class_lookups[lookup_name]
+
+
+def select_related_descend(field, restricted, requested, load_fields, reverse=False):
+    """
+    Return True if this field should be used to descend deeper for
+    select_related() purposes. Used by both the query construction code
+    (sql.query.fill_related_selections()) and the model instance creation code
+    (query.get_klass_info()).
+
+    Arguments:
+     * field - the field to be checked
+     * restricted - a boolean field, indicating if the field list has been
+       manually restricted using a requested clause)
+     * requested - The select_related() dictionary.
+     * load_fields - the set of fields to be loaded on this model
+     * reverse - boolean, True if we are checking a reverse select related
+    """
+    if not field.remote_field:
+        return False
+    if field.remote_field.parent_link and not reverse:
+        return False
+    if restricted:
+        if reverse and field.related_query_name() not in requested:
+            return False
+        if not reverse and field.name not in requested:
+            return False
+    if not restricted and field.null:
+        return False
+    if load_fields:
+        if field.attname not in load_fields:
+            if restricted and field.name in requested:
+                raise InvalidQuery("Field %s.%s cannot be both deferred"
+                                   " and traversed using select_related"
+                                   " at the same time." %
+                                   (field.model._meta.object_name, field.name))
+    return True
+
+
+def refs_expression(lookup_parts, annotations):
+    """
+    Check if the lookup_parts contains references to the given annotations set.
+    Because the LOOKUP_SEP is contained in the default annotation names, check
+    each prefix of the lookup_parts for a match.
+    """
+    for n in range(1, len(lookup_parts) + 1):
+        level_n_lookup = LOOKUP_SEP.join(lookup_parts[0:n])
+        if level_n_lookup in annotations and annotations[level_n_lookup]:
+            return annotations[level_n_lookup], lookup_parts[n:]
+    return False, ()
+
+
+def check_rel_lookup_compatibility(model, target_opts, field):
+    """
+    Check that self.model is compatible with target_opts. Compatibility
+    is OK if:
+      1) model and opts match (where proxy inheritance is removed)
+      2) model is parent of opts' model or the other way around
+    """
+    def check(opts):
+        return (
+            model._meta.concrete_model == opts.concrete_model or
+            opts.concrete_model in model._meta.get_parent_list() or
+            model in opts.get_parent_list()
+        )
+    # If the field is a primary key, then doing a query against the field's
+    # model is ok, too. Consider the case:
+    # class Restaurant(models.Model):
+    #     place = OneToOneField(Place, primary_key=True):
+    # Restaurant.objects.filter(pk__in=Restaurant.objects.all()).
+    # If we didn't have the primary key check, then pk__in (== place__in) would
+    # give Place's opts as the target opts, but Restaurant isn't compatible
+    # with that. This logic applies only to primary keys, as when doing __in=qs,
+    # we are going to turn this into __in=qs.values('pk') later on.
+    return (
+        check(target_opts) or
+        (getattr(field, 'primary_key', False) and check(field.model._meta))
+    )
+
+
+class FilteredRelation:
+    """Specify custom filtering in the ON clause of SQL joins."""
+
+    def __init__(self, relation_name, *, condition=Q()):
+        if not relation_name:
+            raise ValueError('relation_name cannot be empty.')
+        self.relation_name = relation_name
+        self.alias = None
+        if not isinstance(condition, Q):
+            raise ValueError('condition argument must be a Q() instance.')
+        self.condition = condition
+        self.path = []
+
+    def __eq__(self, other):
+        return (
+            isinstance(other, self.__class__) and
+            self.relation_name == other.relation_name and
+            self.alias == other.alias and
+            self.condition == other.condition
+        )
+
+    def clone(self):
+        clone = FilteredRelation(self.relation_name, condition=self.condition)
+        clone.alias = self.alias
+        clone.path = self.path[:]
+        return clone
+
+    def resolve_expression(self, *args, **kwargs):
+        """
+        QuerySet.annotate() only accepts expression-like arguments
+        (with a resolve_expression() method).
+        """
+        raise NotImplementedError('FilteredRelation.resolve_expression() is unused.')
+
+    def as_sql(self, compiler, connection):
+        # Resolve the condition in Join.filtered_relation.
+        query = compiler.query
+        where = query.build_filtered_relation_q(self.condition, reuse=set(self.path))
+        return compiler.compile(where)

venv/lib/python3.8/site-packages/django/db/models/signals.py

@@ -0,0 +1,53 @@
+from functools import partial
+
+from django.db.models.utils import make_model_tuple
+from django.dispatch import Signal
+
+class_prepared = Signal(providing_args=["class"])
+
+
+class ModelSignal(Signal):
+    """
+    Signal subclass that allows the sender to be lazily specified as a string
+    of the `app_label.ModelName` form.
+    """
+    def _lazy_method(self, method, apps, receiver, sender, **kwargs):
+        from django.db.models.options import Options
+
+        # This partial takes a single optional argument named "sender".
+        partial_method = partial(method, receiver, **kwargs)
+        if isinstance(sender, str):
+            apps = apps or Options.default_apps
+            apps.lazy_model_operation(partial_method, make_model_tuple(sender))
+        else:
+            return partial_method(sender)
+
+    def connect(self, receiver, sender=None, weak=True, dispatch_uid=None, apps=None):
+        self._lazy_method(
+            super().connect, apps, receiver, sender,
+            weak=weak, dispatch_uid=dispatch_uid,
+        )
+
+    def disconnect(self, receiver=None, sender=None, dispatch_uid=None, apps=None):
+        return self._lazy_method(
+            super().disconnect, apps, receiver, sender, dispatch_uid=dispatch_uid
+        )
+
+
+pre_init = ModelSignal(providing_args=["instance", "args", "kwargs"], use_caching=True)
+post_init = ModelSignal(providing_args=["instance"], use_caching=True)
+
+pre_save = ModelSignal(providing_args=["instance", "raw", "using", "update_fields"],
+                       use_caching=True)
+post_save = ModelSignal(providing_args=["instance", "raw", "created", "using", "update_fields"], use_caching=True)
+
+pre_delete = ModelSignal(providing_args=["instance", "using"], use_caching=True)
+post_delete = ModelSignal(providing_args=["instance", "using"], use_caching=True)
+
+m2m_changed = ModelSignal(
+    providing_args=["action", "instance", "reverse", "model", "pk_set", "using"],
+    use_caching=True,
+)
+
+pre_migrate = Signal(providing_args=["app_config", "verbosity", "interactive", "using", "apps", "plan"])
+post_migrate = Signal(providing_args=["app_config", "verbosity", "interactive", "using", "apps", "plan"])

venv/lib/python3.8/site-packages/django/db/models/sql/__init__.py

@@ -0,0 +1,7 @@
+from django.core.exceptions import EmptyResultSet
+from django.db.models.sql.query import *  # NOQA
+from django.db.models.sql.query import Query
+from django.db.models.sql.subqueries import *  # NOQA
+from django.db.models.sql.where import AND, OR
+
+__all__ = ['Query', 'AND', 'OR', 'EmptyResultSet']

venv/lib/python3.8/site-packages/django/db/models/sql/constants.py

@@ -0,0 +1,27 @@
+"""
+Constants specific to the SQL storage portion of the ORM.
+"""
+
+import re
+
+# Size of each "chunk" for get_iterator calls.
+# Larger values are slightly faster at the expense of more storage space.
+GET_ITERATOR_CHUNK_SIZE = 100
+
+# Namedtuples for sql.* internal use.
+
+# How many results to expect from a cursor.execute call
+MULTI = 'multi'
+SINGLE = 'single'
+CURSOR = 'cursor'
+NO_RESULTS = 'no results'
+
+ORDER_PATTERN = re.compile(r'\?|[-+]?[.\w]+$')
+ORDER_DIR = {
+    'ASC': ('ASC', 'DESC'),
+    'DESC': ('DESC', 'ASC'),
+}
+
+# SQL join types.
+INNER = 'INNER JOIN'
+LOUTER = 'LEFT OUTER JOIN'

venv/lib/python3.8/site-packages/django/db/models/sql/datastructures.py

@@ -0,0 +1,170 @@
+"""
+Useful auxiliary data structures for query construction. Not useful outside
+the SQL domain.
+"""
+# for backwards-compatibility in Django 1.11
+from django.core.exceptions import EmptyResultSet  # NOQA: F401
+from django.db.models.sql.constants import INNER, LOUTER
+
+
+class MultiJoin(Exception):
+    """
+    Used by join construction code to indicate the point at which a
+    multi-valued join was attempted (if the caller wants to treat that
+    exceptionally).
+    """
+    def __init__(self, names_pos, path_with_names):
+        self.level = names_pos
+        # The path travelled, this includes the path to the multijoin.
+        self.names_with_path = path_with_names
+
+
+class Empty:
+    pass
+
+
+class Join:
+    """
+    Used by sql.Query and sql.SQLCompiler to generate JOIN clauses into the
+    FROM entry. For example, the SQL generated could be
+        LEFT OUTER JOIN "sometable" T1 ON ("othertable"."sometable_id" = "sometable"."id")
+
+    This class is primarily used in Query.alias_map. All entries in alias_map
+    must be Join compatible by providing the following attributes and methods:
+        - table_name (string)
+        - table_alias (possible alias for the table, can be None)
+        - join_type (can be None for those entries that aren't joined from
+          anything)
+        - parent_alias (which table is this join's parent, can be None similarly
+          to join_type)
+        - as_sql()
+        - relabeled_clone()
+    """
+    def __init__(self, table_name, parent_alias, table_alias, join_type,
+                 join_field, nullable, filtered_relation=None):
+        # Join table
+        self.table_name = table_name
+        self.parent_alias = parent_alias
+        # Note: table_alias is not necessarily known at instantiation time.
+        self.table_alias = table_alias
+        # LOUTER or INNER
+        self.join_type = join_type
+        # A list of 2-tuples to use in the ON clause of the JOIN.
+        # Each 2-tuple will create one join condition in the ON clause.
+        self.join_cols = join_field.get_joining_columns()
+        # Along which field (or ForeignObjectRel in the reverse join case)
+        self.join_field = join_field
+        # Is this join nullabled?
+        self.nullable = nullable
+        self.filtered_relation = filtered_relation
+
+    def as_sql(self, compiler, connection):
+        """
+        Generate the full
+           LEFT OUTER JOIN sometable ON sometable.somecol = othertable.othercol, params
+        clause for this join.
+        """
+        join_conditions = []
+        params = []
+        qn = compiler.quote_name_unless_alias
+        qn2 = connection.ops.quote_name
+
+        # Add a join condition for each pair of joining columns.
+        for lhs_col, rhs_col in self.join_cols:
+            join_conditions.append('%s.%s = %s.%s' % (
+                qn(self.parent_alias),
+                qn2(lhs_col),
+                qn(self.table_alias),
+                qn2(rhs_col),
+            ))
+
+        # Add a single condition inside parentheses for whatever
+        # get_extra_restriction() returns.
+        extra_cond = self.join_field.get_extra_restriction(
+            compiler.query.where_class, self.table_alias, self.parent_alias)
+        if extra_cond:
+            extra_sql, extra_params = compiler.compile(extra_cond)
+            join_conditions.append('(%s)' % extra_sql)
+            params.extend(extra_params)
+        if self.filtered_relation:
+            extra_sql, extra_params = compiler.compile(self.filtered_relation)
+            if extra_sql:
+                join_conditions.append('(%s)' % extra_sql)
+                params.extend(extra_params)
+        if not join_conditions:
+            # This might be a rel on the other end of an actual declared field.
+            declared_field = getattr(self.join_field, 'field', self.join_field)
+            raise ValueError(
+                "Join generated an empty ON clause. %s did not yield either "
+                "joining columns or extra restrictions." % declared_field.__class__
+            )
+        on_clause_sql = ' AND '.join(join_conditions)
+        alias_str = '' if self.table_alias == self.table_name else (' %s' % self.table_alias)
+        sql = '%s %s%s ON (%s)' % (self.join_type, qn(self.table_name), alias_str, on_clause_sql)
+        return sql, params
+
+    def relabeled_clone(self, change_map):
+        new_parent_alias = change_map.get(self.parent_alias, self.parent_alias)
+        new_table_alias = change_map.get(self.table_alias, self.table_alias)
+        if self.filtered_relation is not None:
+            filtered_relation = self.filtered_relation.clone()
+            filtered_relation.path = [change_map.get(p, p) for p in self.filtered_relation.path]
+        else:
+            filtered_relation = None
+        return self.__class__(
+            self.table_name, new_parent_alias, new_table_alias, self.join_type,
+            self.join_field, self.nullable, filtered_relation=filtered_relation,
+        )
+
+    def equals(self, other, with_filtered_relation):
+        return (
+            isinstance(other, self.__class__) and
+            self.table_name == other.table_name and
+            self.parent_alias == other.parent_alias and
+            self.join_field == other.join_field and
+            (not with_filtered_relation or self.filtered_relation == other.filtered_relation)
+        )
+
+    def __eq__(self, other):
+        return self.equals(other, with_filtered_relation=True)
+
+    def demote(self):
+        new = self.relabeled_clone({})
+        new.join_type = INNER
+        return new
+
+    def promote(self):
+        new = self.relabeled_clone({})
+        new.join_type = LOUTER
+        return new
+
+
+class BaseTable:
+    """
+    The BaseTable class is used for base table references in FROM clause. For
+    example, the SQL "foo" in
+        SELECT * FROM "foo" WHERE somecond
+    could be generated by this class.
+    """
+    join_type = None
+    parent_alias = None
+    filtered_relation = None
+
+    def __init__(self, table_name, alias):
+        self.table_name = table_name
+        self.table_alias = alias
+
+    def as_sql(self, compiler, connection):
+        alias_str = '' if self.table_alias == self.table_name else (' %s' % self.table_alias)
+        base_sql = compiler.quote_name_unless_alias(self.table_name)
+        return base_sql + alias_str, []
+
+    def relabeled_clone(self, change_map):
+        return self.__class__(self.table_name, change_map.get(self.table_alias, self.table_alias))
+
+    def equals(self, other, with_filtered_relation):
+        return (
+            isinstance(self, other.__class__) and
+            self.table_name == other.table_name and
+            self.table_alias == other.table_alias
+        )

venv/lib/python3.8/site-packages/django/db/models/sql/subqueries.py

@@ -0,0 +1,194 @@
+"""
+Query subclasses which provide extra functionality beyond simple data retrieval.
+"""
+
+from django.core.exceptions import FieldError
+from django.db import connections
+from django.db.models.query_utils import Q
+from django.db.models.sql.constants import (
+    CURSOR, GET_ITERATOR_CHUNK_SIZE, NO_RESULTS,
+)
+from django.db.models.sql.query import Query
+
+__all__ = ['DeleteQuery', 'UpdateQuery', 'InsertQuery', 'AggregateQuery']
+
+
+class DeleteQuery(Query):
+    """A DELETE SQL query."""
+
+    compiler = 'SQLDeleteCompiler'
+
+    def do_query(self, table, where, using):
+        self.alias_map = {table: self.alias_map[table]}
+        self.where = where
+        cursor = self.get_compiler(using).execute_sql(CURSOR)
+        return cursor.rowcount if cursor else 0
+
+    def delete_batch(self, pk_list, using):
+        """
+        Set up and execute delete queries for all the objects in pk_list.
+
+        More than one physical query may be executed if there are a
+        lot of values in pk_list.
+        """
+        # number of objects deleted
+        num_deleted = 0
+        field = self.get_meta().pk
+        for offset in range(0, len(pk_list), GET_ITERATOR_CHUNK_SIZE):
+            self.where = self.where_class()
+            self.add_q(Q(
+                **{field.attname + '__in': pk_list[offset:offset + GET_ITERATOR_CHUNK_SIZE]}))
+            num_deleted += self.do_query(self.get_meta().db_table, self.where, using=using)
+        return num_deleted
+
+    def delete_qs(self, query, using):
+        """
+        Delete the queryset in one SQL query (if possible). For simple queries
+        this is done by copying the query.query.where to self.query, for
+        complex queries by using subquery.
+        """
+        innerq = query.query
+        # Make sure the inner query has at least one table in use.
+        innerq.get_initial_alias()
+        # The same for our new query.
+        self.get_initial_alias()
+        innerq_used_tables = tuple([t for t in innerq.alias_map if innerq.alias_refcount[t]])
+        if not innerq_used_tables or innerq_used_tables == tuple(self.alias_map):
+            # There is only the base table in use in the query.
+            self.where = innerq.where
+        else:
+            pk = query.model._meta.pk
+            if not connections[using].features.update_can_self_select:
+                # We can't do the delete using subquery.
+                values = list(query.values_list('pk', flat=True))
+                if not values:
+                    return 0
+                return self.delete_batch(values, using)
+            else:
+                innerq.clear_select_clause()
+                innerq.select = [
+                    pk.get_col(self.get_initial_alias())
+                ]
+                values = innerq
+            self.where = self.where_class()
+            self.add_q(Q(pk__in=values))
+        cursor = self.get_compiler(using).execute_sql(CURSOR)
+        return cursor.rowcount if cursor else 0
+
+
+class UpdateQuery(Query):
+    """An UPDATE SQL query."""
+
+    compiler = 'SQLUpdateCompiler'
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._setup_query()
+
+    def _setup_query(self):
+        """
+        Run on initialization and at the end of chaining. Any attributes that
+        would normally be set in __init__() should go here instead.
+        """
+        self.values = []
+        self.related_ids = None
+        self.related_updates = {}
+
+    def clone(self):
+        obj = super().clone()
+        obj.related_updates = self.related_updates.copy()
+        return obj
+
+    def update_batch(self, pk_list, values, using):
+        self.add_update_values(values)
+        for offset in range(0, len(pk_list), GET_ITERATOR_CHUNK_SIZE):
+            self.where = self.where_class()
+            self.add_q(Q(pk__in=pk_list[offset: offset + GET_ITERATOR_CHUNK_SIZE]))
+            self.get_compiler(using).execute_sql(NO_RESULTS)
+
+    def add_update_values(self, values):
+        """
+        Convert a dictionary of field name to value mappings into an update
+        query. This is the entry point for the public update() method on
+        querysets.
+        """
+        values_seq = []
+        for name, val in values.items():
+            field = self.get_meta().get_field(name)
+            direct = not (field.auto_created and not field.concrete) or not field.concrete
+            model = field.model._meta.concrete_model
+            if not direct or (field.is_relation and field.many_to_many):
+                raise FieldError(
+                    'Cannot update model field %r (only non-relations and '
+                    'foreign keys permitted).' % field
+                )
+            if model is not self.get_meta().concrete_model:
+                self.add_related_update(model, field, val)
+                continue
+            values_seq.append((field, model, val))
+        return self.add_update_fields(values_seq)
+
+    def add_update_fields(self, values_seq):
+        """
+        Append a sequence of (field, model, value) triples to the internal list
+        that will be used to generate the UPDATE query. Might be more usefully
+        called add_update_targets() to hint at the extra information here.
+        """
+        for field, model, val in values_seq:
+            if hasattr(val, 'resolve_expression'):
+                # Resolve expressions here so that annotations are no longer needed
+                val = val.resolve_expression(self, allow_joins=False, for_save=True)
+            self.values.append((field, model, val))
+
+    def add_related_update(self, model, field, value):
+        """
+        Add (name, value) to an update query for an ancestor model.
+
+        Update are coalesced so that only one update query per ancestor is run.
+        """
+        self.related_updates.setdefault(model, []).append((field, None, value))
+
+    def get_related_updates(self):
+        """
+        Return a list of query objects: one for each update required to an
+        ancestor model. Each query will have the same filtering conditions as
+        the current query but will only update a single table.
+        """
+        if not self.related_updates:
+            return []
+        result = []
+        for model, values in self.related_updates.items():
+            query = UpdateQuery(model)
+            query.values = values
+            if self.related_ids is not None:
+                query.add_filter(('pk__in', self.related_ids))
+            result.append(query)
+        return result
+
+
+class InsertQuery(Query):
+    compiler = 'SQLInsertCompiler'
+
+    def __init__(self, *args, ignore_conflicts=False, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.fields = []
+        self.objs = []
+        self.ignore_conflicts = ignore_conflicts
+
+    def insert_values(self, fields, objs, raw=False):
+        self.fields = fields
+        self.objs = objs
+        self.raw = raw
+
+
+class AggregateQuery(Query):
+    """
+    Take another query as a parameter to the FROM clause and only select the
+    elements in the provided list.
+    """
+
+    compiler = 'SQLAggregateCompiler'
+
+    def add_subquery(self, query, using):
+        query.subquery = True
+        self.subquery, self.sub_params = query.get_compiler(using).as_sql(with_col_aliases=True)

venv/lib/python3.8/site-packages/django/db/models/sql/where.py

@@ -0,0 +1,245 @@
+"""
+Code to manage the creation and SQL rendering of 'where' constraints.
+"""
+
+from django.core.exceptions import EmptyResultSet
+from django.utils import tree
+from django.utils.functional import cached_property
+
+# Connection types
+AND = 'AND'
+OR = 'OR'
+
+
+class WhereNode(tree.Node):
+    """
+    An SQL WHERE clause.
+
+    The class is tied to the Query class that created it (in order to create
+    the correct SQL).
+
+    A child is usually an expression producing boolean values. Most likely the
+    expression is a Lookup instance.
+
+    However, a child could also be any class with as_sql() and either
+    relabeled_clone() method or relabel_aliases() and clone() methods and
+    contains_aggregate attribute.
+    """
+    default = AND
+    resolved = False
+    conditional = True
+
+    def split_having(self, negated=False):
+        """
+        Return two possibly None nodes: one for those parts of self that
+        should be included in the WHERE clause and one for those parts of
+        self that must be included in the HAVING clause.
+        """
+        if not self.contains_aggregate:
+            return self, None
+        in_negated = negated ^ self.negated
+        # If the effective connector is OR and this node contains an aggregate,
+        # then we need to push the whole branch to HAVING clause.
+        may_need_split = (
+            (in_negated and self.connector == AND) or
+            (not in_negated and self.connector == OR))
+        if may_need_split and self.contains_aggregate:
+            return None, self
+        where_parts = []
+        having_parts = []
+        for c in self.children:
+            if hasattr(c, 'split_having'):
+                where_part, having_part = c.split_having(in_negated)
+                if where_part is not None:
+                    where_parts.append(where_part)
+                if having_part is not None:
+                    having_parts.append(having_part)
+            elif c.contains_aggregate:
+                having_parts.append(c)
+            else:
+                where_parts.append(c)
+        having_node = self.__class__(having_parts, self.connector, self.negated) if having_parts else None
+        where_node = self.__class__(where_parts, self.connector, self.negated) if where_parts else None
+        return where_node, having_node
+
+    def as_sql(self, compiler, connection):
+        """
+        Return the SQL version of the where clause and the value to be
+        substituted in. Return '', [] if this node matches everything,
+        None, [] if this node is empty, and raise EmptyResultSet if this
+        node can't match anything.
+        """
+        result = []
+        result_params = []
+        if self.connector == AND:
+            full_needed, empty_needed = len(self.children), 1
+        else:
+            full_needed, empty_needed = 1, len(self.children)
+
+        for child in self.children:
+            try:
+                sql, params = compiler.compile(child)
+            except EmptyResultSet:
+                empty_needed -= 1
+            else:
+                if sql:
+                    result.append(sql)
+                    result_params.extend(params)
+                else:
+                    full_needed -= 1
+            # Check if this node matches nothing or everything.
+            # First check the amount of full nodes and empty nodes
+            # to make this node empty/full.
+            # Now, check if this node is full/empty using the
+            # counts.
+            if empty_needed == 0:
+                if self.negated:
+                    return '', []
+                else:
+                    raise EmptyResultSet
+            if full_needed == 0:
+                if self.negated:
+                    raise EmptyResultSet
+                else:
+                    return '', []
+        conn = ' %s ' % self.connector
+        sql_string = conn.join(result)
+        if sql_string:
+            if self.negated:
+                # Some backends (Oracle at least) need parentheses
+                # around the inner SQL in the negated case, even if the
+                # inner SQL contains just a single expression.
+                sql_string = 'NOT (%s)' % sql_string
+            elif len(result) > 1 or self.resolved:
+                sql_string = '(%s)' % sql_string
+        return sql_string, result_params
+
+    def get_group_by_cols(self, alias=None):
+        cols = []
+        for child in self.children:
+            cols.extend(child.get_group_by_cols())
+        return cols
+
+    def get_source_expressions(self):
+        return self.children[:]
+
+    def set_source_expressions(self, children):
+        assert len(children) == len(self.children)
+        self.children = children
+
+    def relabel_aliases(self, change_map):
+        """
+        Relabel the alias values of any children. 'change_map' is a dictionary
+        mapping old (current) alias values to the new values.
+        """
+        for pos, child in enumerate(self.children):
+            if hasattr(child, 'relabel_aliases'):
+                # For example another WhereNode
+                child.relabel_aliases(change_map)
+            elif hasattr(child, 'relabeled_clone'):
+                self.children[pos] = child.relabeled_clone(change_map)
+
+    def clone(self):
+        """
+        Create a clone of the tree. Must only be called on root nodes (nodes
+        with empty subtree_parents). Childs must be either (Constraint, lookup,
+        value) tuples, or objects supporting .clone().
+        """
+        clone = self.__class__._new_instance(
+            children=[], connector=self.connector, negated=self.negated)
+        for child in self.children:
+            if hasattr(child, 'clone'):
+                clone.children.append(child.clone())
+            else:
+                clone.children.append(child)
+        return clone
+
+    def relabeled_clone(self, change_map):
+        clone = self.clone()
+        clone.relabel_aliases(change_map)
+        return clone
+
+    @classmethod
+    def _contains_aggregate(cls, obj):
+        if isinstance(obj, tree.Node):
+            return any(cls._contains_aggregate(c) for c in obj.children)
+        return obj.contains_aggregate
+
+    @cached_property
+    def contains_aggregate(self):
+        return self._contains_aggregate(self)
+
+    @classmethod
+    def _contains_over_clause(cls, obj):
+        if isinstance(obj, tree.Node):
+            return any(cls._contains_over_clause(c) for c in obj.children)
+        return obj.contains_over_clause
+
+    @cached_property
+    def contains_over_clause(self):
+        return self._contains_over_clause(self)
+
+    @property
+    def is_summary(self):
+        return any(child.is_summary for child in self.children)
+
+    @staticmethod
+    def _resolve_leaf(expr, query, *args, **kwargs):
+        if hasattr(expr, 'resolve_expression'):
+            expr = expr.resolve_expression(query, *args, **kwargs)
+        return expr
+
+    @classmethod
+    def _resolve_node(cls, node, query, *args, **kwargs):
+        if hasattr(node, 'children'):
+            for child in node.children:
+                cls._resolve_node(child, query, *args, **kwargs)
+        if hasattr(node, 'lhs'):
+            node.lhs = cls._resolve_leaf(node.lhs, query, *args, **kwargs)
+        if hasattr(node, 'rhs'):
+            node.rhs = cls._resolve_leaf(node.rhs, query, *args, **kwargs)
+
+    def resolve_expression(self, *args, **kwargs):
+        clone = self.clone()
+        clone._resolve_node(clone, *args, **kwargs)
+        clone.resolved = True
+        return clone
+
+
+class NothingNode:
+    """A node that matches nothing."""
+    contains_aggregate = False
+
+    def as_sql(self, compiler=None, connection=None):
+        raise EmptyResultSet
+
+
+class ExtraWhere:
+    # The contents are a black box - assume no aggregates are used.
+    contains_aggregate = False
+
+    def __init__(self, sqls, params):
+        self.sqls = sqls
+        self.params = params
+
+    def as_sql(self, compiler=None, connection=None):
+        sqls = ["(%s)" % sql for sql in self.sqls]
+        return " AND ".join(sqls), list(self.params or ())
+
+
+class SubqueryConstraint:
+    # Even if aggregates would be used in a subquery, the outer query isn't
+    # interested about those.
+    contains_aggregate = False
+
+    def __init__(self, alias, columns, targets, query_object):
+        self.alias = alias
+        self.columns = columns
+        self.targets = targets
+        self.query_object = query_object
+
+    def as_sql(self, compiler, connection):
+        query = self.query_object
+        query.set_values(self.targets)
+        query_compiler = query.get_compiler(connection=connection)
+        return query_compiler.as_subquery_condition(self.alias, self.columns, compiler)

venv/lib/python3.8/site-packages/django/db/models/utils.py

@@ -0,0 +1,21 @@
+def make_model_tuple(model):
+    """
+    Take a model or a string of the form "app_label.ModelName" and return a
+    corresponding ("app_label", "modelname") tuple. If a tuple is passed in,
+    assume it's a valid model tuple already and return it unchanged.
+    """
+    try:
+        if isinstance(model, tuple):
+            model_tuple = model
+        elif isinstance(model, str):
+            app_label, model_name = model.split(".")
+            model_tuple = app_label, model_name.lower()
+        else:
+            model_tuple = model._meta.app_label, model._meta.model_name
+        assert len(model_tuple) == 2
+        return model_tuple
+    except (ValueError, AssertionError):
+        raise ValueError(
+            "Invalid model reference '%s'. String model references "
+            "must be of the form 'app_label.ModelName'." % model
+        )