17.12

venv/lib/python3.7/site-packages/django/db/backends/base/client.py

@@ -0,0 +1,12 @@
+class BaseDatabaseClient:
+    """Encapsulate backend-specific methods for opening a client shell."""
+    # This should be a string representing the name of the executable
+    # (e.g., "psql"). Subclasses must override this.
+    executable_name = None
+
+    def __init__(self, connection):
+        # connection is an instance of BaseDatabaseWrapper.
+        self.connection = connection
+
+    def runshell(self):
+        raise NotImplementedError('subclasses of BaseDatabaseClient must provide a runshell() method')

venv/lib/python3.7/site-packages/django/db/backends/base/features.py

@@ -0,0 +1,308 @@
+from django.db.utils import ProgrammingError
+from django.utils.functional import cached_property
+
+
+class BaseDatabaseFeatures:
+    gis_enabled = False
+    allows_group_by_pk = False
+    allows_group_by_selected_pks = False
+    empty_fetchmany_value = []
+    update_can_self_select = True
+
+    # Does the backend distinguish between '' and None?
+    interprets_empty_strings_as_nulls = False
+
+    # Does the backend allow inserting duplicate NULL rows in a nullable
+    # unique field? All core backends implement this correctly, but other
+    # databases such as SQL Server do not.
+    supports_nullable_unique_constraints = True
+
+    # Does the backend allow inserting duplicate rows when a unique_together
+    # constraint exists and some fields are nullable but not all of them?
+    supports_partially_nullable_unique_constraints = True
+
+    can_use_chunked_reads = True
+    can_return_id_from_insert = False
+    can_return_ids_from_bulk_insert = False
+    has_bulk_insert = True
+    uses_savepoints = True
+    can_release_savepoints = False
+
+    # If True, don't use integer foreign keys referring to, e.g., positive
+    # integer primary keys.
+    related_fields_match_type = False
+    allow_sliced_subqueries_with_in = True
+    has_select_for_update = False
+    has_select_for_update_nowait = False
+    has_select_for_update_skip_locked = False
+    has_select_for_update_of = False
+    # Does the database's SELECT FOR UPDATE OF syntax require a column rather
+    # than a table?
+    select_for_update_of_column = False
+
+    # Does the default test database allow multiple connections?
+    # Usually an indication that the test database is in-memory
+    test_db_allows_multiple_connections = True
+
+    # Can an object be saved without an explicit primary key?
+    supports_unspecified_pk = False
+
+    # Can a fixture contain forward references? i.e., are
+    # FK constraints checked at the end of transaction, or
+    # at the end of each save operation?
+    supports_forward_references = True
+
+    # Does the backend truncate names properly when they are too long?
+    truncates_names = False
+
+    # Is there a REAL datatype in addition to floats/doubles?
+    has_real_datatype = False
+    supports_subqueries_in_group_by = True
+
+    # Is there a true datatype for uuid?
+    has_native_uuid_field = False
+
+    # Is there a true datatype for timedeltas?
+    has_native_duration_field = False
+
+    # Does the database driver supports same type temporal data subtraction
+    # by returning the type used to store duration field?
+    supports_temporal_subtraction = False
+
+    # Does the __regex lookup support backreferencing and grouping?
+    supports_regex_backreferencing = True
+
+    # Can date/datetime lookups be performed using a string?
+    supports_date_lookup_using_string = True
+
+    # Can datetimes with timezones be used?
+    supports_timezones = True
+
+    # Does the database have a copy of the zoneinfo database?
+    has_zoneinfo_database = True
+
+    # When performing a GROUP BY, is an ORDER BY NULL required
+    # to remove any ordering?
+    requires_explicit_null_ordering_when_grouping = False
+
+    # Does the backend order NULL values as largest or smallest?
+    nulls_order_largest = False
+
+    # The database's limit on the number of query parameters.
+    max_query_params = None
+
+    # Can an object have an autoincrement primary key of 0? MySQL says No.
+    allows_auto_pk_0 = True
+
+    # Do we need to NULL a ForeignKey out, or can the constraint check be
+    # deferred
+    can_defer_constraint_checks = False
+
+    # date_interval_sql can properly handle mixed Date/DateTime fields and timedeltas
+    supports_mixed_date_datetime_comparisons = True
+
+    # Does the backend support tablespaces? Default to False because it isn't
+    # in the SQL standard.
+    supports_tablespaces = False
+
+    # Does the backend reset sequences between tests?
+    supports_sequence_reset = True
+
+    # Can the backend introspect the default value of a column?
+    can_introspect_default = True
+
+    # Confirm support for introspected foreign keys
+    # Every database can do this reliably, except MySQL,
+    # which can't do it for MyISAM tables
+    can_introspect_foreign_keys = True
+
+    # Can the backend introspect an AutoField, instead of an IntegerField?
+    can_introspect_autofield = False
+
+    # Can the backend introspect a BigIntegerField, instead of an IntegerField?
+    can_introspect_big_integer_field = True
+
+    # Can the backend introspect an BinaryField, instead of an TextField?
+    can_introspect_binary_field = True
+
+    # Can the backend introspect an DecimalField, instead of an FloatField?
+    can_introspect_decimal_field = True
+
+    # Can the backend introspect a DurationField, instead of a BigIntegerField?
+    can_introspect_duration_field = True
+
+    # Can the backend introspect an IPAddressField, instead of an CharField?
+    can_introspect_ip_address_field = False
+
+    # Can the backend introspect a PositiveIntegerField, instead of an IntegerField?
+    can_introspect_positive_integer_field = False
+
+    # Can the backend introspect a SmallIntegerField, instead of an IntegerField?
+    can_introspect_small_integer_field = False
+
+    # Can the backend introspect a TimeField, instead of a DateTimeField?
+    can_introspect_time_field = True
+
+    # Some backends may not be able to differentiate BigAutoField from other
+    # fields such as AutoField.
+    introspected_big_auto_field_type = 'BigAutoField'
+
+    # Some backends may not be able to differentiate BooleanField from other
+    # fields such as IntegerField.
+    introspected_boolean_field_type = 'BooleanField'
+
+    # Can the backend introspect the column order (ASC/DESC) for indexes?
+    supports_index_column_ordering = True
+
+    # Does the backend support introspection of materialized views?
+    can_introspect_materialized_views = False
+
+    # Support for the DISTINCT ON clause
+    can_distinct_on_fields = False
+
+    # Does the backend decide to commit before SAVEPOINT statements
+    # when autocommit is disabled? https://bugs.python.org/issue8145#msg109965
+    autocommits_when_autocommit_is_off = False
+
+    # Does the backend prevent running SQL queries in broken transactions?
+    atomic_transactions = True
+
+    # Can we roll back DDL in a transaction?
+    can_rollback_ddl = False
+
+    # Does it support operations requiring references rename in a transaction?
+    supports_atomic_references_rename = True
+
+    # Can we issue more than one ALTER COLUMN clause in an ALTER TABLE?
+    supports_combined_alters = False
+
+    # Does it support foreign keys?
+    supports_foreign_keys = True
+
+    # Does it support CHECK constraints?
+    supports_column_check_constraints = True
+    supports_table_check_constraints = True
+
+    # Does the backend support 'pyformat' style ("... %(name)s ...", {'name': value})
+    # parameter passing? Note this can be provided by the backend even if not
+    # supported by the Python driver
+    supports_paramstyle_pyformat = True
+
+    # Does the backend require literal defaults, rather than parameterized ones?
+    requires_literal_defaults = False
+
+    # Does the backend require a connection reset after each material schema change?
+    connection_persists_old_columns = False
+
+    # What kind of error does the backend throw when accessing closed cursor?
+    closed_cursor_error_class = ProgrammingError
+
+    # Does 'a' LIKE 'A' match?
+    has_case_insensitive_like = True
+
+    # Suffix for backends that don't support "SELECT xxx;" queries.
+    bare_select_suffix = ''
+
+    # If NULL is implied on columns without needing to be explicitly specified
+    implied_column_null = False
+
+    # Does the backend support "select for update" queries with limit (and offset)?
+    supports_select_for_update_with_limit = True
+
+    # Does the backend ignore null expressions in GREATEST and LEAST queries unless
+    # every expression is null?
+    greatest_least_ignores_nulls = False
+
+    # Can the backend clone databases for parallel test execution?
+    # Defaults to False to allow third-party backends to opt-in.
+    can_clone_databases = False
+
+    # Does the backend consider table names with different casing to
+    # be equal?
+    ignores_table_name_case = False
+
+    # Place FOR UPDATE right after FROM clause. Used on MSSQL.
+    for_update_after_from = False
+
+    # Combinatorial flags
+    supports_select_union = True
+    supports_select_intersection = True
+    supports_select_difference = True
+    supports_slicing_ordering_in_compound = False
+    supports_parentheses_in_compound = True
+
+    # Does the database support SQL 2003 FILTER (WHERE ...) in aggregate
+    # expressions?
+    supports_aggregate_filter_clause = False
+
+    # Does the backend support indexing a TextField?
+    supports_index_on_text_field = True
+
+    # Does the backend support window expressions (expression OVER (...))?
+    supports_over_clause = False
+
+    # Does the backend support CAST with precision?
+    supports_cast_with_precision = True
+
+    # How many second decimals does the database return when casting a value to
+    # a type with time?
+    time_cast_precision = 6
+
+    # SQL to create a procedure for use by the Django test suite. The
+    # functionality of the procedure isn't important.
+    create_test_procedure_without_params_sql = None
+    create_test_procedure_with_int_param_sql = None
+
+    # Does the backend support keyword parameters for cursor.callproc()?
+    supports_callproc_kwargs = False
+
+    # Convert CharField results from bytes to str in database functions.
+    db_functions_convert_bytes_to_str = False
+
+    # What formats does the backend EXPLAIN syntax support?
+    supported_explain_formats = set()
+
+    # Does DatabaseOperations.explain_query_prefix() raise ValueError if
+    # unknown kwargs are passed to QuerySet.explain()?
+    validates_explain_options = True
+
+    # Does the backend support the default parameter in lead() and lag()?
+    supports_default_in_lead_lag = True
+
+    # Does the backend support ignoring constraint or uniqueness errors during
+    # INSERT?
+    supports_ignore_conflicts = True
+
+    # Does this backend require casting the results of CASE expressions used
+    # in UPDATE statements to ensure the expression has the correct type?
+    requires_casted_case_in_updates = False
+
+    # Does the backend support partial indexes (CREATE INDEX ... WHERE ...)?
+    supports_partial_indexes = True
+    supports_functions_in_partial_indexes = True
+
+    # Does the database allow more than one constraint or index on the same
+    # field(s)?
+    allows_multiple_constraints_on_same_fields = True
+
+    def __init__(self, connection):
+        self.connection = connection
+
+    @cached_property
+    def supports_explaining_query_execution(self):
+        """Does this backend support explaining query execution?"""
+        return self.connection.ops.explain_prefix is not None
+
+    @cached_property
+    def supports_transactions(self):
+        """Confirm support for transactions."""
+        with self.connection.cursor() as cursor:
+            cursor.execute('CREATE TABLE ROLLBACK_TEST (X INT)')
+            self.connection.set_autocommit(False)
+            cursor.execute('INSERT INTO ROLLBACK_TEST (X) VALUES (8)')
+            self.connection.rollback()
+            self.connection.set_autocommit(True)
+            cursor.execute('SELECT COUNT(X) FROM ROLLBACK_TEST')
+            count, = cursor.fetchone()
+            cursor.execute('DROP TABLE ROLLBACK_TEST')
+        return count == 0

venv/lib/python3.7/site-packages/django/db/backends/base/validation.py

@@ -0,0 +1,25 @@
+class BaseDatabaseValidation:
+    """Encapsulate backend-specific validation."""
+    def __init__(self, connection):
+        self.connection = connection
+
+    def check(self, **kwargs):
+        return []
+
+    def check_field(self, field, **kwargs):
+        errors = []
+        # Backends may implement a check_field_type() method.
+        if (hasattr(self, 'check_field_type') and
+                # Ignore any related fields.
+                not getattr(field, 'remote_field', None)):
+            # Ignore fields with unsupported features.
+            db_supports_all_required_features = all(
+                getattr(self.connection.features, feature, False)
+                for feature in field.model._meta.required_db_features
+            )
+            if db_supports_all_required_features:
+                field_type = field.db_type(self.connection)
+                # Ignore non-concrete fields.
+                if field_type is not None:
+                    errors.extend(self.check_field_type(field, field_type))
+        return errors

venv/lib/python3.7/site-packages/django/db/backends/mysql/client.py

@@ -0,0 +1,48 @@
+import subprocess
+
+from django.db.backends.base.client import BaseDatabaseClient
+
+
+class DatabaseClient(BaseDatabaseClient):
+    executable_name = 'mysql'
+
+    @classmethod
+    def settings_to_cmd_args(cls, settings_dict):
+        args = [cls.executable_name]
+        db = settings_dict['OPTIONS'].get('db', settings_dict['NAME'])
+        user = settings_dict['OPTIONS'].get('user', settings_dict['USER'])
+        passwd = settings_dict['OPTIONS'].get('passwd', settings_dict['PASSWORD'])
+        host = settings_dict['OPTIONS'].get('host', settings_dict['HOST'])
+        port = settings_dict['OPTIONS'].get('port', settings_dict['PORT'])
+        server_ca = settings_dict['OPTIONS'].get('ssl', {}).get('ca')
+        client_cert = settings_dict['OPTIONS'].get('ssl', {}).get('cert')
+        client_key = settings_dict['OPTIONS'].get('ssl', {}).get('key')
+        defaults_file = settings_dict['OPTIONS'].get('read_default_file')
+        # Seems to be no good way to set sql_mode with CLI.
+
+        if defaults_file:
+            args += ["--defaults-file=%s" % defaults_file]
+        if user:
+            args += ["--user=%s" % user]
+        if passwd:
+            args += ["--password=%s" % passwd]
+        if host:
+            if '/' in host:
+                args += ["--socket=%s" % host]
+            else:
+                args += ["--host=%s" % host]
+        if port:
+            args += ["--port=%s" % port]
+        if server_ca:
+            args += ["--ssl-ca=%s" % server_ca]
+        if client_cert:
+            args += ["--ssl-cert=%s" % client_cert]
+        if client_key:
+            args += ["--ssl-key=%s" % client_key]
+        if db:
+            args += [db]
+        return args
+
+    def runshell(self):
+        args = DatabaseClient.settings_to_cmd_args(self.connection.settings_dict)
+        subprocess.check_call(args)

venv/lib/python3.7/site-packages/django/db/backends/mysql/creation.py

@@ -0,0 +1,67 @@
+import subprocess
+import sys
+
+from django.db.backends.base.creation import BaseDatabaseCreation
+
+from .client import DatabaseClient
+
+
+class DatabaseCreation(BaseDatabaseCreation):
+
+    def sql_table_creation_suffix(self):
+        suffix = []
+        test_settings = self.connection.settings_dict['TEST']
+        if test_settings['CHARSET']:
+            suffix.append('CHARACTER SET %s' % test_settings['CHARSET'])
+        if test_settings['COLLATION']:
+            suffix.append('COLLATE %s' % test_settings['COLLATION'])
+        return ' '.join(suffix)
+
+    def _execute_create_test_db(self, cursor, parameters, keepdb=False):
+        try:
+            super()._execute_create_test_db(cursor, parameters, keepdb)
+        except Exception as e:
+            if len(e.args) < 1 or e.args[0] != 1007:
+                # All errors except "database exists" (1007) cancel tests.
+                self.log('Got an error creating the test database: %s' % e)
+                sys.exit(2)
+            else:
+                raise e
+
+    def _clone_test_db(self, suffix, verbosity, keepdb=False):
+        source_database_name = self.connection.settings_dict['NAME']
+        target_database_name = self.get_test_db_clone_settings(suffix)['NAME']
+        test_db_params = {
+            'dbname': self.connection.ops.quote_name(target_database_name),
+            'suffix': self.sql_table_creation_suffix(),
+        }
+        with self._nodb_connection.cursor() as cursor:
+            try:
+                self._execute_create_test_db(cursor, test_db_params, keepdb)
+            except Exception:
+                if keepdb:
+                    # If the database should be kept, skip everything else.
+                    return
+                try:
+                    if verbosity >= 1:
+                        self.log('Destroying old test database for alias %s...' % (
+                            self._get_database_display_str(verbosity, target_database_name),
+                        ))
+                    cursor.execute('DROP DATABASE %(dbname)s' % test_db_params)
+                    self._execute_create_test_db(cursor, test_db_params, keepdb)
+                except Exception as e:
+                    self.log('Got an error recreating the test database: %s' % e)
+                    sys.exit(2)
+        self._clone_db(source_database_name, target_database_name)
+
+    def _clone_db(self, source_database_name, target_database_name):
+        dump_args = DatabaseClient.settings_to_cmd_args(self.connection.settings_dict)[1:]
+        dump_args[-1] = source_database_name
+        dump_cmd = ['mysqldump', '--routines', '--events'] + dump_args
+        load_cmd = DatabaseClient.settings_to_cmd_args(self.connection.settings_dict)
+        load_cmd[-1] = target_database_name
+
+        with subprocess.Popen(dump_cmd, stdout=subprocess.PIPE) as dump_proc:
+            with subprocess.Popen(load_cmd, stdin=dump_proc.stdout, stdout=subprocess.DEVNULL):
+                # Allow dump_proc to receive a SIGPIPE if the load process exits.
+                dump_proc.stdout.close()

venv/lib/python3.7/site-packages/django/db/backends/mysql/features.py

@@ -0,0 +1,120 @@
+import operator
+
+from django.db.backends.base.features import BaseDatabaseFeatures
+from django.utils.functional import cached_property
+
+
+class DatabaseFeatures(BaseDatabaseFeatures):
+    empty_fetchmany_value = ()
+    update_can_self_select = False
+    allows_group_by_pk = True
+    related_fields_match_type = True
+    # MySQL doesn't support sliced subqueries with IN/ALL/ANY/SOME.
+    allow_sliced_subqueries_with_in = False
+    has_select_for_update = True
+    supports_forward_references = False
+    supports_regex_backreferencing = False
+    supports_date_lookup_using_string = False
+    can_introspect_autofield = True
+    can_introspect_binary_field = False
+    can_introspect_duration_field = False
+    can_introspect_small_integer_field = True
+    can_introspect_positive_integer_field = True
+    introspected_boolean_field_type = 'IntegerField'
+    supports_index_column_ordering = False
+    supports_timezones = False
+    requires_explicit_null_ordering_when_grouping = True
+    allows_auto_pk_0 = False
+    can_release_savepoints = True
+    atomic_transactions = False
+    supports_column_check_constraints = False
+    supports_table_check_constraints = False
+    can_clone_databases = True
+    supports_temporal_subtraction = True
+    supports_select_intersection = False
+    supports_select_difference = False
+    supports_slicing_ordering_in_compound = True
+    supports_index_on_text_field = False
+    has_case_insensitive_like = False
+    create_test_procedure_without_params_sql = """
+        CREATE PROCEDURE test_procedure ()
+        BEGIN
+            DECLARE V_I INTEGER;
+            SET V_I = 1;
+        END;
+    """
+    create_test_procedure_with_int_param_sql = """
+        CREATE PROCEDURE test_procedure (P_I INTEGER)
+        BEGIN
+            DECLARE V_I INTEGER;
+            SET V_I = P_I;
+        END;
+    """
+    db_functions_convert_bytes_to_str = True
+    # Alias MySQL's TRADITIONAL to TEXT for consistency with other backends.
+    supported_explain_formats = {'JSON', 'TEXT', 'TRADITIONAL'}
+    # Neither MySQL nor MariaDB support partial indexes.
+    supports_partial_indexes = False
+
+    @cached_property
+    def _mysql_storage_engine(self):
+        "Internal method used in Django tests. Don't rely on this from your code"
+        with self.connection.cursor() as cursor:
+            cursor.execute("SELECT ENGINE FROM INFORMATION_SCHEMA.ENGINES WHERE SUPPORT = 'DEFAULT'")
+            result = cursor.fetchone()
+        return result[0]
+
+    @cached_property
+    def can_introspect_foreign_keys(self):
+        "Confirm support for introspected foreign keys"
+        return self._mysql_storage_engine != 'MyISAM'
+
+    @cached_property
+    def has_zoneinfo_database(self):
+        # Test if the time zone definitions are installed.
+        with self.connection.cursor() as cursor:
+            cursor.execute("SELECT 1 FROM mysql.time_zone LIMIT 1")
+            return cursor.fetchone() is not None
+
+    @cached_property
+    def is_sql_auto_is_null_enabled(self):
+        with self.connection.cursor() as cursor:
+            cursor.execute('SELECT @@SQL_AUTO_IS_NULL')
+            result = cursor.fetchone()
+            return result and result[0] == 1
+
+    @cached_property
+    def supports_over_clause(self):
+        if self.connection.mysql_is_mariadb:
+            return self.connection.mysql_version >= (10, 2)
+        return self.connection.mysql_version >= (8, 0, 2)
+
+    @cached_property
+    def has_select_for_update_skip_locked(self):
+        return not self.connection.mysql_is_mariadb and self.connection.mysql_version >= (8, 0, 1)
+
+    has_select_for_update_nowait = property(operator.attrgetter('has_select_for_update_skip_locked'))
+
+    @cached_property
+    def needs_explain_extended(self):
+        # EXTENDED is deprecated (and not required) in MySQL 5.7.
+        return not self.connection.mysql_is_mariadb and self.connection.mysql_version < (5, 7)
+
+    @cached_property
+    def supports_transactions(self):
+        """
+        All storage engines except MyISAM support transactions.
+        """
+        return self._mysql_storage_engine != 'MyISAM'
+
+    @cached_property
+    def ignores_table_name_case(self):
+        with self.connection.cursor() as cursor:
+            cursor.execute('SELECT @@LOWER_CASE_TABLE_NAMES')
+            result = cursor.fetchone()
+            return result and result[0] != 0
+
+    @cached_property
+    def supports_default_in_lead_lag(self):
+        # To be added in https://jira.mariadb.org/browse/MDEV-12981.
+        return not self.connection.mysql_is_mariadb

venv/lib/python3.7/site-packages/django/db/backends/mysql/operations.py

@@ -0,0 +1,306 @@
+import uuid
+
+from django.conf import settings
+from django.db.backends.base.operations import BaseDatabaseOperations
+from django.utils import timezone
+from django.utils.duration import duration_microseconds
+
+
+class DatabaseOperations(BaseDatabaseOperations):
+    compiler_module = "django.db.backends.mysql.compiler"
+
+    # MySQL stores positive fields as UNSIGNED ints.
+    integer_field_ranges = {
+        **BaseDatabaseOperations.integer_field_ranges,
+        'PositiveSmallIntegerField': (0, 65535),
+        'PositiveIntegerField': (0, 4294967295),
+    }
+    cast_data_types = {
+        'AutoField': 'signed integer',
+        'BigAutoField': 'signed integer',
+        'CharField': 'char(%(max_length)s)',
+        'DecimalField': 'decimal(%(max_digits)s, %(decimal_places)s)',
+        'TextField': 'char',
+        'IntegerField': 'signed integer',
+        'BigIntegerField': 'signed integer',
+        'SmallIntegerField': 'signed integer',
+        'PositiveIntegerField': 'unsigned integer',
+        'PositiveSmallIntegerField': 'unsigned integer',
+    }
+    cast_char_field_without_max_length = 'char'
+    explain_prefix = 'EXPLAIN'
+
+    def date_extract_sql(self, lookup_type, field_name):
+        # https://dev.mysql.com/doc/mysql/en/date-and-time-functions.html
+        if lookup_type == 'week_day':
+            # DAYOFWEEK() returns an integer, 1-7, Sunday=1.
+            # Note: WEEKDAY() returns 0-6, Monday=0.
+            return "DAYOFWEEK(%s)" % field_name
+        elif lookup_type == 'week':
+            # Override the value of default_week_format for consistency with
+            # other database backends.
+            # Mode 3: Monday, 1-53, with 4 or more days this year.
+            return "WEEK(%s, 3)" % field_name
+        elif lookup_type == 'iso_year':
+            # Get the year part from the YEARWEEK function, which returns a
+            # number as year * 100 + week.
+            return "TRUNCATE(YEARWEEK(%s, 3), -2) / 100" % field_name
+        else:
+            # EXTRACT returns 1-53 based on ISO-8601 for the week number.
+            return "EXTRACT(%s FROM %s)" % (lookup_type.upper(), field_name)
+
+    def date_trunc_sql(self, lookup_type, field_name):
+        fields = {
+            'year': '%%Y-01-01',
+            'month': '%%Y-%%m-01',
+        }  # Use double percents to escape.
+        if lookup_type in fields:
+            format_str = fields[lookup_type]
+            return "CAST(DATE_FORMAT(%s, '%s') AS DATE)" % (field_name, format_str)
+        elif lookup_type == 'quarter':
+            return "MAKEDATE(YEAR(%s), 1) + INTERVAL QUARTER(%s) QUARTER - INTERVAL 1 QUARTER" % (
+                field_name, field_name
+            )
+        elif lookup_type == 'week':
+            return "DATE_SUB(%s, INTERVAL WEEKDAY(%s) DAY)" % (
+                field_name, field_name
+            )
+        else:
+            return "DATE(%s)" % (field_name)
+
+    def _convert_field_to_tz(self, field_name, tzname):
+        if settings.USE_TZ:
+            field_name = "CONVERT_TZ(%s, 'UTC', '%s')" % (field_name, tzname)
+        return field_name
+
+    def datetime_cast_date_sql(self, field_name, tzname):
+        field_name = self._convert_field_to_tz(field_name, tzname)
+        return "DATE(%s)" % field_name
+
+    def datetime_cast_time_sql(self, field_name, tzname):
+        field_name = self._convert_field_to_tz(field_name, tzname)
+        return "TIME(%s)" % field_name
+
+    def datetime_extract_sql(self, lookup_type, field_name, tzname):
+        field_name = self._convert_field_to_tz(field_name, tzname)
+        return self.date_extract_sql(lookup_type, field_name)
+
+    def datetime_trunc_sql(self, lookup_type, field_name, tzname):
+        field_name = self._convert_field_to_tz(field_name, tzname)
+        fields = ['year', 'month', 'day', 'hour', 'minute', 'second']
+        format = ('%%Y-', '%%m', '-%%d', ' %%H:', '%%i', ':%%s')  # Use double percents to escape.
+        format_def = ('0000-', '01', '-01', ' 00:', '00', ':00')
+        if lookup_type == 'quarter':
+            return (
+                "CAST(DATE_FORMAT(MAKEDATE(YEAR({field_name}), 1) + "
+                "INTERVAL QUARTER({field_name}) QUARTER - " +
+                "INTERVAL 1 QUARTER, '%%Y-%%m-01 00:00:00') AS DATETIME)"
+            ).format(field_name=field_name)
+        if lookup_type == 'week':
+            return (
+                "CAST(DATE_FORMAT(DATE_SUB({field_name}, "
+                "INTERVAL WEEKDAY({field_name}) DAY), "
+                "'%%Y-%%m-%%d 00:00:00') AS DATETIME)"
+            ).format(field_name=field_name)
+        try:
+            i = fields.index(lookup_type) + 1
+        except ValueError:
+            sql = field_name
+        else:
+            format_str = ''.join([f for f in format[:i]] + [f for f in format_def[i:]])
+            sql = "CAST(DATE_FORMAT(%s, '%s') AS DATETIME)" % (field_name, format_str)
+        return sql
+
+    def time_trunc_sql(self, lookup_type, field_name):
+        fields = {
+            'hour': '%%H:00:00',
+            'minute': '%%H:%%i:00',
+            'second': '%%H:%%i:%%s',
+        }  # Use double percents to escape.
+        if lookup_type in fields:
+            format_str = fields[lookup_type]
+            return "CAST(DATE_FORMAT(%s, '%s') AS TIME)" % (field_name, format_str)
+        else:
+            return "TIME(%s)" % (field_name)
+
+    def date_interval_sql(self, timedelta):
+        return 'INTERVAL %s MICROSECOND' % duration_microseconds(timedelta)
+
+    def format_for_duration_arithmetic(self, sql):
+        return 'INTERVAL %s MICROSECOND' % sql
+
+    def force_no_ordering(self):
+        """
+        "ORDER BY NULL" prevents MySQL from implicitly ordering by grouped
+        columns. If no ordering would otherwise be applied, we don't want any
+        implicit sorting going on.
+        """
+        return [(None, ("NULL", [], False))]
+
+    def last_executed_query(self, cursor, sql, params):
+        # With MySQLdb, cursor objects have an (undocumented) "_executed"
+        # attribute where the exact query sent to the database is saved.
+        # See MySQLdb/cursors.py in the source distribution.
+        query = getattr(cursor, '_executed', None)
+        if query is not None:
+            query = query.decode(errors='replace')
+        return query
+
+    def no_limit_value(self):
+        # 2**64 - 1, as recommended by the MySQL documentation
+        return 18446744073709551615
+
+    def quote_name(self, name):
+        if name.startswith("`") and name.endswith("`"):
+            return name  # Quoting once is enough.
+        return "`%s`" % name
+
+    def random_function_sql(self):
+        return 'RAND()'
+
+    def sql_flush(self, style, tables, sequences, allow_cascade=False):
+        # NB: The generated SQL below is specific to MySQL
+        # 'TRUNCATE x;', 'TRUNCATE y;', 'TRUNCATE z;'... style SQL statements
+        # to clear all tables of all data
+        if tables:
+            sql = ['SET FOREIGN_KEY_CHECKS = 0;']
+            for table in tables:
+                sql.append('%s %s;' % (
+                    style.SQL_KEYWORD('TRUNCATE'),
+                    style.SQL_FIELD(self.quote_name(table)),
+                ))
+            sql.append('SET FOREIGN_KEY_CHECKS = 1;')
+            sql.extend(self.sequence_reset_by_name_sql(style, sequences))
+            return sql
+        else:
+            return []
+
+    def validate_autopk_value(self, value):
+        # MySQLism: zero in AUTO_INCREMENT field does not work. Refs #17653.
+        if value == 0:
+            raise ValueError('The database backend does not accept 0 as a '
+                             'value for AutoField.')
+        return value
+
+    def adapt_datetimefield_value(self, value):
+        if value is None:
+            return None
+
+        # Expression values are adapted by the database.
+        if hasattr(value, 'resolve_expression'):
+            return value
+
+        # MySQL doesn't support tz-aware datetimes
+        if timezone.is_aware(value):
+            if settings.USE_TZ:
+                value = timezone.make_naive(value, self.connection.timezone)
+            else:
+                raise ValueError("MySQL backend does not support timezone-aware datetimes when USE_TZ is False.")
+        return str(value)
+
+    def adapt_timefield_value(self, value):
+        if value is None:
+            return None
+
+        # Expression values are adapted by the database.
+        if hasattr(value, 'resolve_expression'):
+            return value
+
+        # MySQL doesn't support tz-aware times
+        if timezone.is_aware(value):
+            raise ValueError("MySQL backend does not support timezone-aware times.")
+
+        return str(value)
+
+    def max_name_length(self):
+        return 64
+
+    def bulk_insert_sql(self, fields, placeholder_rows):
+        placeholder_rows_sql = (", ".join(row) for row in placeholder_rows)
+        values_sql = ", ".join("(%s)" % sql for sql in placeholder_rows_sql)
+        return "VALUES " + values_sql
+
+    def combine_expression(self, connector, sub_expressions):
+        if connector == '^':
+            return 'POW(%s)' % ','.join(sub_expressions)
+        # Convert the result to a signed integer since MySQL's binary operators
+        # return an unsigned integer.
+        elif connector in ('&', '|', '<<'):
+            return 'CONVERT(%s, SIGNED)' % connector.join(sub_expressions)
+        elif connector == '>>':
+            lhs, rhs = sub_expressions
+            return 'FLOOR(%(lhs)s / POW(2, %(rhs)s))' % {'lhs': lhs, 'rhs': rhs}
+        return super().combine_expression(connector, sub_expressions)
+
+    def get_db_converters(self, expression):
+        converters = super().get_db_converters(expression)
+        internal_type = expression.output_field.get_internal_type()
+        if internal_type in ['BooleanField', 'NullBooleanField']:
+            converters.append(self.convert_booleanfield_value)
+        elif internal_type == 'DateTimeField':
+            if settings.USE_TZ:
+                converters.append(self.convert_datetimefield_value)
+        elif internal_type == 'UUIDField':
+            converters.append(self.convert_uuidfield_value)
+        return converters
+
+    def convert_booleanfield_value(self, value, expression, connection):
+        if value in (0, 1):
+            value = bool(value)
+        return value
+
+    def convert_datetimefield_value(self, value, expression, connection):
+        if value is not None:
+            value = timezone.make_aware(value, self.connection.timezone)
+        return value
+
+    def convert_uuidfield_value(self, value, expression, connection):
+        if value is not None:
+            value = uuid.UUID(value)
+        return value
+
+    def binary_placeholder_sql(self, value):
+        return '_binary %s' if value is not None and not hasattr(value, 'as_sql') else '%s'
+
+    def subtract_temporals(self, internal_type, lhs, rhs):
+        lhs_sql, lhs_params = lhs
+        rhs_sql, rhs_params = rhs
+        if internal_type == 'TimeField':
+            if self.connection.mysql_is_mariadb:
+                # MariaDB includes the microsecond component in TIME_TO_SEC as
+                # a decimal. MySQL returns an integer without microseconds.
+                return 'CAST((TIME_TO_SEC(%(lhs)s) - TIME_TO_SEC(%(rhs)s)) * 1000000 AS SIGNED)' % {
+                    'lhs': lhs_sql, 'rhs': rhs_sql
+                }, lhs_params + rhs_params
+            return (
+                "((TIME_TO_SEC(%(lhs)s) * 1000000 + MICROSECOND(%(lhs)s)) -"
+                " (TIME_TO_SEC(%(rhs)s) * 1000000 + MICROSECOND(%(rhs)s)))"
+            ) % {'lhs': lhs_sql, 'rhs': rhs_sql}, lhs_params * 2 + rhs_params * 2
+        else:
+            return "TIMESTAMPDIFF(MICROSECOND, %s, %s)" % (rhs_sql, lhs_sql), rhs_params + lhs_params
+
+    def explain_query_prefix(self, format=None, **options):
+        # Alias MySQL's TRADITIONAL to TEXT for consistency with other backends.
+        if format and format.upper() == 'TEXT':
+            format = 'TRADITIONAL'
+        prefix = super().explain_query_prefix(format, **options)
+        if format:
+            prefix += ' FORMAT=%s' % format
+        if self.connection.features.needs_explain_extended and format is None:
+            # EXTENDED and FORMAT are mutually exclusive options.
+            prefix += ' EXTENDED'
+        return prefix
+
+    def regex_lookup(self, lookup_type):
+        # REGEXP BINARY doesn't work correctly in MySQL 8+ and REGEXP_LIKE
+        # doesn't exist in MySQL 5.6 or in MariaDB.
+        if self.connection.mysql_version < (8, 0, 0) or self.connection.mysql_is_mariadb:
+            if lookup_type == 'regex':
+                return '%s REGEXP BINARY %s'
+            return '%s REGEXP %s'
+
+        match_option = 'c' if lookup_type == 'regex' else 'i'
+        return "REGEXP_LIKE(%%s, %%s, '%s')" % match_option
+
+    def insert_statement(self, ignore_conflicts=False):
+        return 'INSERT IGNORE INTO' if ignore_conflicts else super().insert_statement(ignore_conflicts)

venv/lib/python3.7/site-packages/django/db/backends/mysql/schema.py

@@ -0,0 +1,103 @@
+from django.db.backends.base.schema import BaseDatabaseSchemaEditor
+from django.db.models import NOT_PROVIDED
+
+
+class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
+
+    sql_rename_table = "RENAME TABLE %(old_table)s TO %(new_table)s"
+
+    sql_alter_column_null = "MODIFY %(column)s %(type)s NULL"
+    sql_alter_column_not_null = "MODIFY %(column)s %(type)s NOT NULL"
+    sql_alter_column_type = "MODIFY %(column)s %(type)s"
+
+    # No 'CASCADE' which works as a no-op in MySQL but is undocumented
+    sql_delete_column = "ALTER TABLE %(table)s DROP COLUMN %(column)s"
+
+    sql_rename_column = "ALTER TABLE %(table)s CHANGE %(old_column)s %(new_column)s %(type)s"
+
+    sql_delete_unique = "ALTER TABLE %(table)s DROP INDEX %(name)s"
+
+    sql_delete_fk = "ALTER TABLE %(table)s DROP FOREIGN KEY %(name)s"
+
+    sql_delete_index = "DROP INDEX %(name)s ON %(table)s"
+
+    sql_create_pk = "ALTER TABLE %(table)s ADD CONSTRAINT %(name)s PRIMARY KEY (%(columns)s)"
+    sql_delete_pk = "ALTER TABLE %(table)s DROP PRIMARY KEY"
+
+    sql_create_index = 'CREATE INDEX %(name)s ON %(table)s (%(columns)s)%(extra)s'
+
+    def quote_value(self, value):
+        self.connection.ensure_connection()
+        quoted = self.connection.connection.escape(value, self.connection.connection.encoders)
+        if isinstance(value, str):
+            quoted = quoted.decode()
+        return quoted
+
+    def _is_limited_data_type(self, field):
+        db_type = field.db_type(self.connection)
+        return db_type is not None and db_type.lower() in self.connection._limited_data_types
+
+    def skip_default(self, field):
+        return self._is_limited_data_type(field)
+
+    def add_field(self, model, field):
+        super().add_field(model, field)
+
+        # Simulate the effect of a one-off default.
+        # field.default may be unhashable, so a set isn't used for "in" check.
+        if self.skip_default(field) and field.default not in (None, NOT_PROVIDED):
+            effective_default = self.effective_default(field)
+            self.execute('UPDATE %(table)s SET %(column)s = %%s' % {
+                'table': self.quote_name(model._meta.db_table),
+                'column': self.quote_name(field.column),
+            }, [effective_default])
+
+    def _field_should_be_indexed(self, model, field):
+        create_index = super()._field_should_be_indexed(model, field)
+        storage = self.connection.introspection.get_storage_engine(
+            self.connection.cursor(), model._meta.db_table
+        )
+        # No need to create an index for ForeignKey fields except if
+        # db_constraint=False because the index from that constraint won't be
+        # created.
+        if (storage == "InnoDB" and
+                create_index and
+                field.get_internal_type() == 'ForeignKey' and
+                field.db_constraint):
+            return False
+        return not self._is_limited_data_type(field) and create_index
+
+    def _delete_composed_index(self, model, fields, *args):
+        """
+        MySQL can remove an implicit FK index on a field when that field is
+        covered by another index like a unique_together. "covered" here means
+        that the more complex index starts like the simpler one.
+        http://bugs.mysql.com/bug.php?id=37910 / Django ticket #24757
+        We check here before removing the [unique|index]_together if we have to
+        recreate a FK index.
+        """
+        first_field = model._meta.get_field(fields[0])
+        if first_field.get_internal_type() == 'ForeignKey':
+            constraint_names = self._constraint_names(model, [first_field.column], index=True)
+            if not constraint_names:
+                self.execute(self._create_index_sql(model, [first_field], suffix=""))
+        return super()._delete_composed_index(model, fields, *args)
+
+    def _set_field_new_type_null_status(self, field, new_type):
+        """
+        Keep the null property of the old field. If it has changed, it will be
+        handled separately.
+        """
+        if field.null:
+            new_type += " NULL"
+        else:
+            new_type += " NOT NULL"
+        return new_type
+
+    def _alter_column_type_sql(self, model, old_field, new_field, new_type):
+        new_type = self._set_field_new_type_null_status(old_field, new_type)
+        return super()._alter_column_type_sql(model, old_field, new_field, new_type)
+
+    def _rename_field_sql(self, table, old_field, new_field, new_type):
+        new_type = self._set_field_new_type_null_status(old_field, new_type)
+        return super()._rename_field_sql(table, old_field, new_field, new_type)

venv/lib/python3.7/site-packages/django/db/backends/oracle/client.py

@@ -0,0 +1,17 @@
+import shutil
+import subprocess
+
+from django.db.backends.base.client import BaseDatabaseClient
+
+
+class DatabaseClient(BaseDatabaseClient):
+    executable_name = 'sqlplus'
+    wrapper_name = 'rlwrap'
+
+    def runshell(self):
+        conn_string = self.connection._connect_string()
+        args = [self.executable_name, "-L", conn_string]
+        wrapper_path = shutil.which(self.wrapper_name)
+        if wrapper_path:
+            args = [wrapper_path, *args]
+        subprocess.check_call(args)

venv/lib/python3.7/site-packages/django/db/backends/oracle/features.py

@@ -0,0 +1,71 @@
+from django.db.backends.base.features import BaseDatabaseFeatures
+from django.db.utils import InterfaceError
+from django.utils.functional import cached_property
+
+
+class DatabaseFeatures(BaseDatabaseFeatures):
+    interprets_empty_strings_as_nulls = True
+    has_select_for_update = True
+    has_select_for_update_nowait = True
+    has_select_for_update_skip_locked = True
+    has_select_for_update_of = True
+    select_for_update_of_column = True
+    can_return_id_from_insert = True
+    can_introspect_autofield = True
+    supports_subqueries_in_group_by = False
+    supports_transactions = True
+    supports_timezones = False
+    has_native_duration_field = True
+    can_defer_constraint_checks = True
+    supports_partially_nullable_unique_constraints = False
+    truncates_names = True
+    supports_tablespaces = True
+    supports_sequence_reset = False
+    can_introspect_materialized_views = True
+    can_introspect_time_field = False
+    atomic_transactions = False
+    supports_combined_alters = False
+    nulls_order_largest = True
+    requires_literal_defaults = True
+    closed_cursor_error_class = InterfaceError
+    bare_select_suffix = " FROM DUAL"
+    # select for update with limit can be achieved on Oracle, but not with the current backend.
+    supports_select_for_update_with_limit = False
+    supports_temporal_subtraction = True
+    # Oracle doesn't ignore quoted identifiers case but the current backend
+    # does by uppercasing all identifiers.
+    ignores_table_name_case = True
+    supports_index_on_text_field = False
+    has_case_insensitive_like = False
+    create_test_procedure_without_params_sql = """
+        CREATE PROCEDURE "TEST_PROCEDURE" AS
+            V_I INTEGER;
+        BEGIN
+            V_I := 1;
+        END;
+    """
+    create_test_procedure_with_int_param_sql = """
+        CREATE PROCEDURE "TEST_PROCEDURE" (P_I INTEGER) AS
+            V_I INTEGER;
+        BEGIN
+            V_I := P_I;
+        END;
+    """
+    supports_callproc_kwargs = True
+    supports_over_clause = True
+    supports_ignore_conflicts = False
+    max_query_params = 2**16 - 1
+    supports_partial_indexes = False
+    allows_multiple_constraints_on_same_fields = False
+
+    @cached_property
+    def has_fetch_offset_support(self):
+        return self.connection.oracle_version >= (12, 2)
+
+    @cached_property
+    def allow_sliced_subqueries_with_in(self):
+        return self.has_fetch_offset_support
+
+    @cached_property
+    def supports_slicing_ordering_in_compound(self):
+        return self.has_fetch_offset_support

venv/lib/python3.7/site-packages/django/db/backends/oracle/functions.py

@@ -0,0 +1,22 @@
+from django.db.models import DecimalField, DurationField, Func
+
+
+class IntervalToSeconds(Func):
+    function = ''
+    template = """
+    EXTRACT(day from %(expressions)s) * 86400 +
+    EXTRACT(hour from %(expressions)s) * 3600 +
+    EXTRACT(minute from %(expressions)s) * 60 +
+    EXTRACT(second from %(expressions)s)
+    """
+
+    def __init__(self, expression, *, output_field=None, **extra):
+        super().__init__(expression, output_field=output_field or DecimalField(), **extra)
+
+
+class SecondsToInterval(Func):
+    function = 'NUMTODSINTERVAL'
+    template = "%(function)s(%(expressions)s, 'SECOND')"
+
+    def __init__(self, expression, *, output_field=None, **extra):
+        super().__init__(expression, output_field=output_field or DurationField(), **extra)

venv/lib/python3.7/site-packages/django/db/backends/postgresql/base.py

@@ -0,0 +1,283 @@
+"""
+PostgreSQL database backend for Django.
+
+Requires psycopg 2: http://initd.org/projects/psycopg2
+"""
+
+import threading
+import warnings
+
+from django.conf import settings
+from django.core.exceptions import ImproperlyConfigured
+from django.db import connections
+from django.db.backends.base.base import BaseDatabaseWrapper
+from django.db.utils import DatabaseError as WrappedDatabaseError
+from django.utils.functional import cached_property
+from django.utils.safestring import SafeText
+from django.utils.version import get_version_tuple
+
+try:
+    import psycopg2 as Database
+    import psycopg2.extensions
+    import psycopg2.extras
+except ImportError as e:
+    raise ImproperlyConfigured("Error loading psycopg2 module: %s" % e)
+
+
+def psycopg2_version():
+    version = psycopg2.__version__.split(' ', 1)[0]
+    return get_version_tuple(version)
+
+
+PSYCOPG2_VERSION = psycopg2_version()
+
+if PSYCOPG2_VERSION < (2, 5, 4):
+    raise ImproperlyConfigured("psycopg2_version 2.5.4 or newer is required; you have %s" % psycopg2.__version__)
+
+
+# Some of these import psycopg2, so import them after checking if it's installed.
+from .client import DatabaseClient                          # NOQA isort:skip
+from .creation import DatabaseCreation                      # NOQA isort:skip
+from .features import DatabaseFeatures                      # NOQA isort:skip
+from .introspection import DatabaseIntrospection            # NOQA isort:skip
+from .operations import DatabaseOperations                  # NOQA isort:skip
+from .schema import DatabaseSchemaEditor                    # NOQA isort:skip
+from .utils import utc_tzinfo_factory                       # NOQA isort:skip
+
+psycopg2.extensions.register_adapter(SafeText, psycopg2.extensions.QuotedString)
+psycopg2.extras.register_uuid()
+
+# Register support for inet[] manually so we don't have to handle the Inet()
+# object on load all the time.
+INETARRAY_OID = 1041
+INETARRAY = psycopg2.extensions.new_array_type(
+    (INETARRAY_OID,),
+    'INETARRAY',
+    psycopg2.extensions.UNICODE,
+)
+psycopg2.extensions.register_type(INETARRAY)
+
+
+class DatabaseWrapper(BaseDatabaseWrapper):
+    vendor = 'postgresql'
+    display_name = 'PostgreSQL'
+    # This dictionary maps Field objects to their associated PostgreSQL column
+    # types, as strings. Column-type strings can contain format strings; they'll
+    # be interpolated against the values of Field.__dict__ before being output.
+    # If a column type is set to None, it won't be included in the output.
+    data_types = {
+        'AutoField': 'serial',
+        'BigAutoField': 'bigserial',
+        'BinaryField': 'bytea',
+        'BooleanField': 'boolean',
+        'CharField': 'varchar(%(max_length)s)',
+        'DateField': 'date',
+        'DateTimeField': 'timestamp with time zone',
+        'DecimalField': 'numeric(%(max_digits)s, %(decimal_places)s)',
+        'DurationField': 'interval',
+        'FileField': 'varchar(%(max_length)s)',
+        'FilePathField': 'varchar(%(max_length)s)',
+        'FloatField': 'double precision',
+        'IntegerField': 'integer',
+        'BigIntegerField': 'bigint',
+        'IPAddressField': 'inet',
+        'GenericIPAddressField': 'inet',
+        'NullBooleanField': 'boolean',
+        'OneToOneField': 'integer',
+        'PositiveIntegerField': 'integer',
+        'PositiveSmallIntegerField': 'smallint',
+        'SlugField': 'varchar(%(max_length)s)',
+        'SmallIntegerField': 'smallint',
+        'TextField': 'text',
+        'TimeField': 'time',
+        'UUIDField': 'uuid',
+    }
+    data_type_check_constraints = {
+        'PositiveIntegerField': '"%(column)s" >= 0',
+        'PositiveSmallIntegerField': '"%(column)s" >= 0',
+    }
+    operators = {
+        'exact': '= %s',
+        'iexact': '= UPPER(%s)',
+        'contains': 'LIKE %s',
+        'icontains': 'LIKE UPPER(%s)',
+        'regex': '~ %s',
+        'iregex': '~* %s',
+        'gt': '> %s',
+        'gte': '>= %s',
+        'lt': '< %s',
+        'lte': '<= %s',
+        'startswith': 'LIKE %s',
+        'endswith': 'LIKE %s',
+        'istartswith': 'LIKE UPPER(%s)',
+        'iendswith': 'LIKE UPPER(%s)',
+    }
+
+    # The patterns below are used to generate SQL pattern lookup clauses when
+    # the right-hand side of the lookup isn't a raw string (it might be an expression
+    # or the result of a bilateral transformation).
+    # In those cases, special characters for LIKE operators (e.g. \, *, _) should be
+    # escaped on database side.
+    #
+    # Note: we use str.format() here for readability as '%' is used as a wildcard for
+    # the LIKE operator.
+    pattern_esc = r"REPLACE(REPLACE(REPLACE({}, E'\\', E'\\\\'), E'%%', E'\\%%'), E'_', E'\\_')"
+    pattern_ops = {
+        'contains': "LIKE '%%' || {} || '%%'",
+        'icontains': "LIKE '%%' || UPPER({}) || '%%'",
+        'startswith': "LIKE {} || '%%'",
+        'istartswith': "LIKE UPPER({}) || '%%'",
+        'endswith': "LIKE '%%' || {}",
+        'iendswith': "LIKE '%%' || UPPER({})",
+    }
+
+    Database = Database
+    SchemaEditorClass = DatabaseSchemaEditor
+    # Classes instantiated in __init__().
+    client_class = DatabaseClient
+    creation_class = DatabaseCreation
+    features_class = DatabaseFeatures
+    introspection_class = DatabaseIntrospection
+    ops_class = DatabaseOperations
+    # PostgreSQL backend-specific attributes.
+    _named_cursor_idx = 0
+
+    def get_connection_params(self):
+        settings_dict = self.settings_dict
+        # None may be used to connect to the default 'postgres' db
+        if settings_dict['NAME'] == '':
+            raise ImproperlyConfigured(
+                "settings.DATABASES is improperly configured. "
+                "Please supply the NAME value.")
+        if len(settings_dict['NAME'] or '') > self.ops.max_name_length():
+            raise ImproperlyConfigured(
+                "The database name '%s' (%d characters) is longer than "
+                "PostgreSQL's limit of %d characters. Supply a shorter NAME "
+                "in settings.DATABASES." % (
+                    settings_dict['NAME'],
+                    len(settings_dict['NAME']),
+                    self.ops.max_name_length(),
+                )
+            )
+        conn_params = {
+            'database': settings_dict['NAME'] or 'postgres',
+            **settings_dict['OPTIONS'],
+        }
+        conn_params.pop('isolation_level', None)
+        if settings_dict['USER']:
+            conn_params['user'] = settings_dict['USER']
+        if settings_dict['PASSWORD']:
+            conn_params['password'] = settings_dict['PASSWORD']
+        if settings_dict['HOST']:
+            conn_params['host'] = settings_dict['HOST']
+        if settings_dict['PORT']:
+            conn_params['port'] = settings_dict['PORT']
+        return conn_params
+
+    def get_new_connection(self, conn_params):
+        connection = Database.connect(**conn_params)
+
+        # self.isolation_level must be set:
+        # - after connecting to the database in order to obtain the database's
+        #   default when no value is explicitly specified in options.
+        # - before calling _set_autocommit() because if autocommit is on, that
+        #   will set connection.isolation_level to ISOLATION_LEVEL_AUTOCOMMIT.
+        options = self.settings_dict['OPTIONS']
+        try:
+            self.isolation_level = options['isolation_level']
+        except KeyError:
+            self.isolation_level = connection.isolation_level
+        else:
+            # Set the isolation level to the value from OPTIONS.
+            if self.isolation_level != connection.isolation_level:
+                connection.set_session(isolation_level=self.isolation_level)
+
+        return connection
+
+    def ensure_timezone(self):
+        if self.connection is None:
+            return False
+        conn_timezone_name = self.connection.get_parameter_status('TimeZone')
+        timezone_name = self.timezone_name
+        if timezone_name and conn_timezone_name != timezone_name:
+            with self.connection.cursor() as cursor:
+                cursor.execute(self.ops.set_time_zone_sql(), [timezone_name])
+            return True
+        return False
+
+    def init_connection_state(self):
+        self.connection.set_client_encoding('UTF8')
+
+        timezone_changed = self.ensure_timezone()
+        if timezone_changed:
+            # Commit after setting the time zone (see #17062)
+            if not self.get_autocommit():
+                self.connection.commit()
+
+    def create_cursor(self, name=None):
+        if name:
+            # In autocommit mode, the cursor will be used outside of a
+            # transaction, hence use a holdable cursor.
+            cursor = self.connection.cursor(name, scrollable=False, withhold=self.connection.autocommit)
+        else:
+            cursor = self.connection.cursor()
+        cursor.tzinfo_factory = utc_tzinfo_factory if settings.USE_TZ else None
+        return cursor
+
+    def chunked_cursor(self):
+        self._named_cursor_idx += 1
+        return self._cursor(
+            name='_django_curs_%d_%d' % (
+                # Avoid reusing name in other threads
+                threading.current_thread().ident,
+                self._named_cursor_idx,
+            )
+        )
+
+    def _set_autocommit(self, autocommit):
+        with self.wrap_database_errors:
+            self.connection.autocommit = autocommit
+
+    def check_constraints(self, table_names=None):
+        """
+        Check constraints by setting them to immediate. Return them to deferred
+        afterward.
+        """
+        self.cursor().execute('SET CONSTRAINTS ALL IMMEDIATE')
+        self.cursor().execute('SET CONSTRAINTS ALL DEFERRED')
+
+    def is_usable(self):
+        try:
+            # Use a psycopg cursor directly, bypassing Django's utilities.
+            self.connection.cursor().execute("SELECT 1")
+        except Database.Error:
+            return False
+        else:
+            return True
+
+    @property
+    def _nodb_connection(self):
+        nodb_connection = super()._nodb_connection
+        try:
+            nodb_connection.ensure_connection()
+        except (Database.DatabaseError, WrappedDatabaseError):
+            warnings.warn(
+                "Normally Django will use a connection to the 'postgres' database "
+                "to avoid running initialization queries against the production "
+                "database when it's not needed (for example, when running tests). "
+                "Django was unable to create a connection to the 'postgres' database "
+                "and will use the first PostgreSQL database instead.",
+                RuntimeWarning
+            )
+            for connection in connections.all():
+                if connection.vendor == 'postgresql' and connection.settings_dict['NAME'] != 'postgres':
+                    return self.__class__(
+                        {**self.settings_dict, 'NAME': connection.settings_dict['NAME']},
+                        alias=self.alias,
+                    )
+        return nodb_connection
+
+    @cached_property
+    def pg_version(self):
+        with self.temporary_connection():
+            return self.connection.server_version

venv/lib/python3.7/site-packages/django/db/backends/postgresql/client.py

@@ -0,0 +1,71 @@
+import os
+import signal
+import subprocess
+
+from django.core.files.temp import NamedTemporaryFile
+from django.db.backends.base.client import BaseDatabaseClient
+
+
+def _escape_pgpass(txt):
+    """
+    Escape a fragment of a PostgreSQL .pgpass file.
+    """
+    return txt.replace('\\', '\\\\').replace(':', '\\:')
+
+
+class DatabaseClient(BaseDatabaseClient):
+    executable_name = 'psql'
+
+    @classmethod
+    def runshell_db(cls, conn_params):
+        args = [cls.executable_name]
+
+        host = conn_params.get('host', '')
+        port = conn_params.get('port', '')
+        dbname = conn_params.get('database', '')
+        user = conn_params.get('user', '')
+        passwd = conn_params.get('password', '')
+
+        if user:
+            args += ['-U', user]
+        if host:
+            args += ['-h', host]
+        if port:
+            args += ['-p', str(port)]
+        args += [dbname]
+
+        temp_pgpass = None
+        sigint_handler = signal.getsignal(signal.SIGINT)
+        try:
+            if passwd:
+                # Create temporary .pgpass file.
+                temp_pgpass = NamedTemporaryFile(mode='w+')
+                try:
+                    print(
+                        _escape_pgpass(host) or '*',
+                        str(port) or '*',
+                        _escape_pgpass(dbname) or '*',
+                        _escape_pgpass(user) or '*',
+                        _escape_pgpass(passwd),
+                        file=temp_pgpass,
+                        sep=':',
+                        flush=True,
+                    )
+                    os.environ['PGPASSFILE'] = temp_pgpass.name
+                except UnicodeEncodeError:
+                    # If the current locale can't encode the data, let the
+                    # user input the password manually.
+                    pass
+            # Allow SIGINT to pass to psql to abort queries.
+            signal.signal(signal.SIGINT, signal.SIG_IGN)
+            subprocess.check_call(args)
+        finally:
+            # Restore the original SIGINT handler.
+            signal.signal(signal.SIGINT, sigint_handler)
+            if temp_pgpass:
+                temp_pgpass.close()
+                if 'PGPASSFILE' in os.environ:  # unit tests need cleanup
+                    del os.environ['PGPASSFILE']
+
+    def runshell(self):
+        DatabaseClient.runshell_db(self.connection.get_connection_params())

venv/lib/python3.7/site-packages/django/db/backends/postgresql/creation.py

@@ -0,0 +1,77 @@
+import sys
+
+from psycopg2 import errorcodes
+
+from django.db.backends.base.creation import BaseDatabaseCreation
+from django.db.backends.utils import strip_quotes
+
+
+class DatabaseCreation(BaseDatabaseCreation):
+
+    def _quote_name(self, name):
+        return self.connection.ops.quote_name(name)
+
+    def _get_database_create_suffix(self, encoding=None, template=None):
+        suffix = ""
+        if encoding:
+            suffix += " ENCODING '{}'".format(encoding)
+        if template:
+            suffix += " TEMPLATE {}".format(self._quote_name(template))
+        return suffix and "WITH" + suffix
+
+    def sql_table_creation_suffix(self):
+        test_settings = self.connection.settings_dict['TEST']
+        assert test_settings['COLLATION'] is None, (
+            "PostgreSQL does not support collation setting at database creation time."
+        )
+        return self._get_database_create_suffix(
+            encoding=test_settings['CHARSET'],
+            template=test_settings.get('TEMPLATE'),
+        )
+
+    def _database_exists(self, cursor, database_name):
+        cursor.execute('SELECT 1 FROM pg_catalog.pg_database WHERE datname = %s', [strip_quotes(database_name)])
+        return cursor.fetchone() is not None
+
+    def _execute_create_test_db(self, cursor, parameters, keepdb=False):
+        try:
+            if keepdb and self._database_exists(cursor, parameters['dbname']):
+                # If the database should be kept and it already exists, don't
+                # try to create a new one.
+                return
+            super()._execute_create_test_db(cursor, parameters, keepdb)
+        except Exception as e:
+            if getattr(e.__cause__, 'pgcode', '') != errorcodes.DUPLICATE_DATABASE:
+                # All errors except "database already exists" cancel tests.
+                self.log('Got an error creating the test database: %s' % e)
+                sys.exit(2)
+            elif not keepdb:
+                # If the database should be kept, ignore "database already
+                # exists".
+                raise e
+
+    def _clone_test_db(self, suffix, verbosity, keepdb=False):
+        # CREATE DATABASE ... WITH TEMPLATE ... requires closing connections
+        # to the template database.
+        self.connection.close()
+
+        source_database_name = self.connection.settings_dict['NAME']
+        target_database_name = self.get_test_db_clone_settings(suffix)['NAME']
+        test_db_params = {
+            'dbname': self._quote_name(target_database_name),
+            'suffix': self._get_database_create_suffix(template=source_database_name),
+        }
+        with self._nodb_connection.cursor() as cursor:
+            try:
+                self._execute_create_test_db(cursor, test_db_params, keepdb)
+            except Exception:
+                try:
+                    if verbosity >= 1:
+                        self.log('Destroying old test database for alias %s...' % (
+                            self._get_database_display_str(verbosity, target_database_name),
+                        ))
+                    cursor.execute('DROP DATABASE %(dbname)s' % test_db_params)
+                    self._execute_create_test_db(cursor, test_db_params, keepdb)
+                except Exception as e:
+                    self.log('Got an error cloning the test database: %s' % e)
+                    sys.exit(2)

venv/lib/python3.7/site-packages/django/db/backends/postgresql/schema.py

@@ -0,0 +1,141 @@
+import psycopg2
+
+from django.db.backends.base.schema import BaseDatabaseSchemaEditor
+from django.db.backends.ddl_references import IndexColumns
+
+
+class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
+
+    sql_alter_column_type = "ALTER COLUMN %(column)s TYPE %(type)s USING %(column)s::%(type)s"
+
+    sql_create_sequence = "CREATE SEQUENCE %(sequence)s"
+    sql_delete_sequence = "DROP SEQUENCE IF EXISTS %(sequence)s CASCADE"
+    sql_set_sequence_max = "SELECT setval('%(sequence)s', MAX(%(column)s)) FROM %(table)s"
+
+    sql_create_index = "CREATE INDEX %(name)s ON %(table)s%(using)s (%(columns)s)%(extra)s%(condition)s"
+    sql_delete_index = "DROP INDEX IF EXISTS %(name)s"
+
+    # Setting the constraint to IMMEDIATE runs any deferred checks to allow
+    # dropping it in the same transaction.
+    sql_delete_fk = "SET CONSTRAINTS %(name)s IMMEDIATE; ALTER TABLE %(table)s DROP CONSTRAINT %(name)s"
+
+    sql_delete_procedure = 'DROP FUNCTION %(procedure)s(%(param_types)s)'
+
+    def quote_value(self, value):
+        if isinstance(value, str):
+            value = value.replace('%', '%%')
+        # getquoted() returns a quoted bytestring of the adapted value.
+        return psycopg2.extensions.adapt(value).getquoted().decode()
+
+    def _field_indexes_sql(self, model, field):
+        output = super()._field_indexes_sql(model, field)
+        like_index_statement = self._create_like_index_sql(model, field)
+        if like_index_statement is not None:
+            output.append(like_index_statement)
+        return output
+
+    def _create_like_index_sql(self, model, field):
+        """
+        Return the statement to create an index with varchar operator pattern
+        when the column type is 'varchar' or 'text', otherwise return None.
+        """
+        db_type = field.db_type(connection=self.connection)
+        if db_type is not None and (field.db_index or field.unique):
+            # Fields with database column types of `varchar` and `text` need
+            # a second index that specifies their operator class, which is
+            # needed when performing correct LIKE queries outside the
+            # C locale. See #12234.
+            #
+            # The same doesn't apply to array fields such as varchar[size]
+            # and text[size], so skip them.
+            if '[' in db_type:
+                return None
+            if db_type.startswith('varchar'):
+                return self._create_index_sql(model, [field], suffix='_like', opclasses=['varchar_pattern_ops'])
+            elif db_type.startswith('text'):
+                return self._create_index_sql(model, [field], suffix='_like', opclasses=['text_pattern_ops'])
+        return None
+
+    def _alter_column_type_sql(self, model, old_field, new_field, new_type):
+        """Make ALTER TYPE with SERIAL make sense."""
+        table = model._meta.db_table
+        if new_type.lower() in ("serial", "bigserial"):
+            column = new_field.column
+            sequence_name = "%s_%s_seq" % (table, column)
+            col_type = "integer" if new_type.lower() == "serial" else "bigint"
+            return (
+                (
+                    self.sql_alter_column_type % {
+                        "column": self.quote_name(column),
+                        "type": col_type,
+                    },
+                    [],
+                ),
+                [
+                    (
+                        self.sql_delete_sequence % {
+                            "sequence": self.quote_name(sequence_name),
+                        },
+                        [],
+                    ),
+                    (
+                        self.sql_create_sequence % {
+                            "sequence": self.quote_name(sequence_name),
+                        },
+                        [],
+                    ),
+                    (
+                        self.sql_alter_column % {
+                            "table": self.quote_name(table),
+                            "changes": self.sql_alter_column_default % {
+                                "column": self.quote_name(column),
+                                "default": "nextval('%s')" % self.quote_name(sequence_name),
+                            }
+                        },
+                        [],
+                    ),
+                    (
+                        self.sql_set_sequence_max % {
+                            "table": self.quote_name(table),
+                            "column": self.quote_name(column),
+                            "sequence": self.quote_name(sequence_name),
+                        },
+                        [],
+                    ),
+                ],
+            )
+        else:
+            return super()._alter_column_type_sql(model, old_field, new_field, new_type)
+
+    def _alter_field(self, model, old_field, new_field, old_type, new_type,
+                     old_db_params, new_db_params, strict=False):
+        # Drop indexes on varchar/text/citext columns that are changing to a
+        # different type.
+        if (old_field.db_index or old_field.unique) and (
+            (old_type.startswith('varchar') and not new_type.startswith('varchar')) or
+            (old_type.startswith('text') and not new_type.startswith('text')) or
+            (old_type.startswith('citext') and not new_type.startswith('citext'))
+        ):
+            index_name = self._create_index_name(model._meta.db_table, [old_field.column], suffix='_like')
+            self.execute(self._delete_index_sql(model, index_name))
+
+        super()._alter_field(
+            model, old_field, new_field, old_type, new_type, old_db_params,
+            new_db_params, strict,
+        )
+        # Added an index? Create any PostgreSQL-specific indexes.
+        if ((not (old_field.db_index or old_field.unique) and new_field.db_index) or
+                (not old_field.unique and new_field.unique)):
+            like_index_statement = self._create_like_index_sql(model, new_field)
+            if like_index_statement is not None:
+                self.execute(like_index_statement)
+
+        # Removed an index? Drop any PostgreSQL-specific indexes.
+        if old_field.unique and not (new_field.db_index or new_field.unique):
+            index_to_remove = self._create_index_name(model._meta.db_table, [old_field.column], suffix='_like')
+            self.execute(self._delete_index_sql(model, index_to_remove))
+
+    def _index_columns(self, table, columns, col_suffixes, opclasses):
+        if opclasses:
+            return IndexColumns(table, columns, self.quote_name, col_suffixes=col_suffixes, opclasses=opclasses)
+        return super()._index_columns(table, columns, col_suffixes, opclasses)

venv/lib/python3.7/site-packages/django/db/backends/postgresql_psycopg2/client.py

@@ -0,0 +1 @@
+from ..postgresql.client import *  # NOQA

venv/lib/python3.7/site-packages/django/db/backends/postgresql_psycopg2/introspection.py

@@ -0,0 +1 @@
+from ..postgresql.introspection import *  # NOQA

venv/lib/python3.7/site-packages/django/db/backends/postgresql_psycopg2/operations.py

@@ -0,0 +1 @@
+from ..postgresql.operations import *  # NOQA

venv/lib/python3.7/site-packages/django/db/backends/postgresql_psycopg2/schema.py

@@ -0,0 +1 @@
+from ..postgresql.schema import *  # NOQA

venv/lib/python3.7/site-packages/django/db/backends/sqlite3/introspection.py

@@ -0,0 +1,434 @@
+import re
+from collections import namedtuple
+
+import sqlparse
+
+from django.db.backends.base.introspection import (
+    BaseDatabaseIntrospection, FieldInfo as BaseFieldInfo, TableInfo,
+)
+from django.db.models.indexes import Index
+
+FieldInfo = namedtuple('FieldInfo', BaseFieldInfo._fields + ('pk',))
+
+field_size_re = re.compile(r'^\s*(?:var)?char\s*\(\s*(\d+)\s*\)\s*$')
+
+
+def get_field_size(name):
+    """ Extract the size number from a "varchar(11)" type name """
+    m = field_size_re.search(name)
+    return int(m.group(1)) if m else None
+
+
+# This light wrapper "fakes" a dictionary interface, because some SQLite data
+# types include variables in them -- e.g. "varchar(30)" -- and can't be matched
+# as a simple dictionary lookup.
+class FlexibleFieldLookupDict:
+    # Maps SQL types to Django Field types. Some of the SQL types have multiple
+    # entries here because SQLite allows for anything and doesn't normalize the
+    # field type; it uses whatever was given.
+    base_data_types_reverse = {
+        'bool': 'BooleanField',
+        'boolean': 'BooleanField',
+        'smallint': 'SmallIntegerField',
+        'smallint unsigned': 'PositiveSmallIntegerField',
+        'smallinteger': 'SmallIntegerField',
+        'int': 'IntegerField',
+        'integer': 'IntegerField',
+        'bigint': 'BigIntegerField',
+        'integer unsigned': 'PositiveIntegerField',
+        'decimal': 'DecimalField',
+        'real': 'FloatField',
+        'text': 'TextField',
+        'char': 'CharField',
+        'varchar': 'CharField',
+        'blob': 'BinaryField',
+        'date': 'DateField',
+        'datetime': 'DateTimeField',
+        'time': 'TimeField',
+    }
+
+    def __getitem__(self, key):
+        key = key.lower().split('(', 1)[0].strip()
+        return self.base_data_types_reverse[key]
+
+
+class DatabaseIntrospection(BaseDatabaseIntrospection):
+    data_types_reverse = FlexibleFieldLookupDict()
+
+    def get_field_type(self, data_type, description):
+        field_type = super().get_field_type(data_type, description)
+        if description.pk and field_type in {'BigIntegerField', 'IntegerField'}:
+            # No support for BigAutoField as SQLite treats all integer primary
+            # keys as signed 64-bit integers.
+            return 'AutoField'
+        return field_type
+
+    def get_table_list(self, cursor):
+        """Return a list of table and view names in the current database."""
+        # Skip the sqlite_sequence system table used for autoincrement key
+        # generation.
+        cursor.execute("""
+            SELECT name, type FROM sqlite_master
+            WHERE type in ('table', 'view') AND NOT name='sqlite_sequence'
+            ORDER BY name""")
+        return [TableInfo(row[0], row[1][0]) for row in cursor.fetchall()]
+
+    def get_table_description(self, cursor, table_name):
+        """
+        Return a description of the table with the DB-API cursor.description
+        interface.
+        """
+        return [
+            FieldInfo(
+                info['name'],
+                info['type'],
+                None,
+                info['size'],
+                None,
+                None,
+                info['null_ok'],
+                info['default'],
+                info['pk'] == 1,
+            ) for info in self._table_info(cursor, table_name)
+        ]
+
+    def get_sequences(self, cursor, table_name, table_fields=()):
+        pk_col = self.get_primary_key_column(cursor, table_name)
+        return [{'table': table_name, 'column': pk_col}]
+
+    def get_relations(self, cursor, table_name):
+        """
+        Return a dictionary of {field_name: (field_name_other_table, other_table)}
+        representing all relationships to the given table.
+        """
+        # Dictionary of relations to return
+        relations = {}
+
+        # Schema for this table
+        cursor.execute(
+            "SELECT sql, type FROM sqlite_master "
+            "WHERE tbl_name = %s AND type IN ('table', 'view')",
+            [table_name]
+        )
+        create_sql, table_type = cursor.fetchone()
+        if table_type == 'view':
+            # It might be a view, then no results will be returned
+            return relations
+        results = create_sql[create_sql.index('(') + 1:create_sql.rindex(')')]
+
+        # Walk through and look for references to other tables. SQLite doesn't
+        # really have enforced references, but since it echoes out the SQL used
+        # to create the table we can look for REFERENCES statements used there.
+        for field_desc in results.split(','):
+            field_desc = field_desc.strip()
+            if field_desc.startswith("UNIQUE"):
+                continue
+
+            m = re.search(r'references (\S*) ?\(["|]?(.*)["|]?\)', field_desc, re.I)
+            if not m:
+                continue
+            table, column = [s.strip('"') for s in m.groups()]
+
+            if field_desc.startswith("FOREIGN KEY"):
+                # Find name of the target FK field
+                m = re.match(r'FOREIGN KEY\s*\(([^\)]*)\).*', field_desc, re.I)
+                field_name = m.groups()[0].strip('"')
+            else:
+                field_name = field_desc.split()[0].strip('"')
+
+            cursor.execute("SELECT sql FROM sqlite_master WHERE tbl_name = %s", [table])
+            result = cursor.fetchall()[0]
+            other_table_results = result[0].strip()
+            li, ri = other_table_results.index('('), other_table_results.rindex(')')
+            other_table_results = other_table_results[li + 1:ri]
+
+            for other_desc in other_table_results.split(','):
+                other_desc = other_desc.strip()
+                if other_desc.startswith('UNIQUE'):
+                    continue
+
+                other_name = other_desc.split(' ', 1)[0].strip('"')
+                if other_name == column:
+                    relations[field_name] = (other_name, table)
+                    break
+
+        return relations
+
+    def get_key_columns(self, cursor, table_name):
+        """
+        Return a list of (column_name, referenced_table_name, referenced_column_name)
+        for all key columns in given table.
+        """
+        key_columns = []
+
+        # Schema for this table
+        cursor.execute("SELECT sql FROM sqlite_master WHERE tbl_name = %s AND type = %s", [table_name, "table"])
+        results = cursor.fetchone()[0].strip()
+        results = results[results.index('(') + 1:results.rindex(')')]
+
+        # Walk through and look for references to other tables. SQLite doesn't
+        # really have enforced references, but since it echoes out the SQL used
+        # to create the table we can look for REFERENCES statements used there.
+        for field_index, field_desc in enumerate(results.split(',')):
+            field_desc = field_desc.strip()
+            if field_desc.startswith("UNIQUE"):
+                continue
+
+            m = re.search(r'"(.*)".*references (.*) \(["|](.*)["|]\)', field_desc, re.I)
+            if not m:
+                continue
+
+            # This will append (column_name, referenced_table_name, referenced_column_name) to key_columns
+            key_columns.append(tuple(s.strip('"') for s in m.groups()))
+
+        return key_columns
+
+    def get_primary_key_column(self, cursor, table_name):
+        """Return the column name of the primary key for the given table."""
+        # Don't use PRAGMA because that causes issues with some transactions
+        cursor.execute(
+            "SELECT sql, type FROM sqlite_master "
+            "WHERE tbl_name = %s AND type IN ('table', 'view')",
+            [table_name]
+        )
+        row = cursor.fetchone()
+        if row is None:
+            raise ValueError("Table %s does not exist" % table_name)
+        create_sql, table_type = row
+        if table_type == 'view':
+            # Views don't have a primary key.
+            return None
+        fields_sql = create_sql[create_sql.index('(') + 1:create_sql.rindex(')')]
+        for field_desc in fields_sql.split(','):
+            field_desc = field_desc.strip()
+            m = re.match(r'(?:(?:["`\[])(.*)(?:["`\]])|(\w+)).*PRIMARY KEY.*', field_desc)
+            if m:
+                return m.group(1) if m.group(1) else m.group(2)
+        return None
+
+    def _table_info(self, cursor, name):
+        cursor.execute('PRAGMA table_info(%s)' % self.connection.ops.quote_name(name))
+        # cid, name, type, notnull, default_value, pk
+        return [{
+            'name': field[1],
+            'type': field[2],
+            'size': get_field_size(field[2]),
+            'null_ok': not field[3],
+            'default': field[4],
+            'pk': field[5],  # undocumented
+        } for field in cursor.fetchall()]
+
+    def _get_foreign_key_constraints(self, cursor, table_name):
+        constraints = {}
+        cursor.execute('PRAGMA foreign_key_list(%s)' % self.connection.ops.quote_name(table_name))
+        for row in cursor.fetchall():
+            # Remaining on_update/on_delete/match values are of no interest.
+            id_, _, table, from_, to = row[:5]
+            constraints['fk_%d' % id_] = {
+                'columns': [from_],
+                'primary_key': False,
+                'unique': False,
+                'foreign_key': (table, to),
+                'check': False,
+                'index': False,
+            }
+        return constraints
+
+    def _parse_column_or_constraint_definition(self, tokens, columns):
+        token = None
+        is_constraint_definition = None
+        field_name = None
+        constraint_name = None
+        unique = False
+        unique_columns = []
+        check = False
+        check_columns = []
+        braces_deep = 0
+        for token in tokens:
+            if token.match(sqlparse.tokens.Punctuation, '('):
+                braces_deep += 1
+            elif token.match(sqlparse.tokens.Punctuation, ')'):
+                braces_deep -= 1
+                if braces_deep < 0:
+                    # End of columns and constraints for table definition.
+                    break
+            elif braces_deep == 0 and token.match(sqlparse.tokens.Punctuation, ','):
+                # End of current column or constraint definition.
+                break
+            # Detect column or constraint definition by first token.
+            if is_constraint_definition is None:
+                is_constraint_definition = token.match(sqlparse.tokens.Keyword, 'CONSTRAINT')
+                if is_constraint_definition:
+                    continue
+            if is_constraint_definition:
+                # Detect constraint name by second token.
+                if constraint_name is None:
+                    if token.ttype in (sqlparse.tokens.Name, sqlparse.tokens.Keyword):
+                        constraint_name = token.value
+                    elif token.ttype == sqlparse.tokens.Literal.String.Symbol:
+                        constraint_name = token.value[1:-1]
+                # Start constraint columns parsing after UNIQUE keyword.
+                if token.match(sqlparse.tokens.Keyword, 'UNIQUE'):
+                    unique = True
+                    unique_braces_deep = braces_deep
+                elif unique:
+                    if unique_braces_deep == braces_deep:
+                        if unique_columns:
+                            # Stop constraint parsing.
+                            unique = False
+                        continue
+                    if token.ttype in (sqlparse.tokens.Name, sqlparse.tokens.Keyword):
+                        unique_columns.append(token.value)
+                    elif token.ttype == sqlparse.tokens.Literal.String.Symbol:
+                        unique_columns.append(token.value[1:-1])
+            else:
+                # Detect field name by first token.
+                if field_name is None:
+                    if token.ttype in (sqlparse.tokens.Name, sqlparse.tokens.Keyword):
+                        field_name = token.value
+                    elif token.ttype == sqlparse.tokens.Literal.String.Symbol:
+                        field_name = token.value[1:-1]
+                if token.match(sqlparse.tokens.Keyword, 'UNIQUE'):
+                    unique_columns = [field_name]
+            # Start constraint columns parsing after CHECK keyword.
+            if token.match(sqlparse.tokens.Keyword, 'CHECK'):
+                check = True
+                check_braces_deep = braces_deep
+            elif check:
+                if check_braces_deep == braces_deep:
+                    if check_columns:
+                        # Stop constraint parsing.
+                        check = False
+                    continue
+                if token.ttype in (sqlparse.tokens.Name, sqlparse.tokens.Keyword):
+                    if token.value in columns:
+                        check_columns.append(token.value)
+                elif token.ttype == sqlparse.tokens.Literal.String.Symbol:
+                    if token.value[1:-1] in columns:
+                        check_columns.append(token.value[1:-1])
+        unique_constraint = {
+            'unique': True,
+            'columns': unique_columns,
+            'primary_key': False,
+            'foreign_key': None,
+            'check': False,
+            'index': False,
+        } if unique_columns else None
+        check_constraint = {
+            'check': True,
+            'columns': check_columns,
+            'primary_key': False,
+            'unique': False,
+            'foreign_key': None,
+            'index': False,
+        } if check_columns else None
+        return constraint_name, unique_constraint, check_constraint, token
+
+    def _parse_table_constraints(self, sql, columns):
+        # Check constraint parsing is based of SQLite syntax diagram.
+        # https://www.sqlite.org/syntaxdiagrams.html#table-constraint
+        statement = sqlparse.parse(sql)[0]
+        constraints = {}
+        unnamed_constrains_index = 0
+        tokens = (token for token in statement.flatten() if not token.is_whitespace)
+        # Go to columns and constraint definition
+        for token in tokens:
+            if token.match(sqlparse.tokens.Punctuation, '('):
+                break
+        # Parse columns and constraint definition
+        while True:
+            constraint_name, unique, check, end_token = self._parse_column_or_constraint_definition(tokens, columns)
+            if unique:
+                if constraint_name:
+                    constraints[constraint_name] = unique
+                else:
+                    unnamed_constrains_index += 1
+                    constraints['__unnamed_constraint_%s__' % unnamed_constrains_index] = unique
+            if check:
+                if constraint_name:
+                    constraints[constraint_name] = check
+                else:
+                    unnamed_constrains_index += 1
+                    constraints['__unnamed_constraint_%s__' % unnamed_constrains_index] = check
+            if end_token.match(sqlparse.tokens.Punctuation, ')'):
+                break
+        return constraints
+
+    def get_constraints(self, cursor, table_name):
+        """
+        Retrieve any constraints or keys (unique, pk, fk, check, index) across
+        one or more columns.
+        """
+        constraints = {}
+        # Find inline check constraints.
+        try:
+            table_schema = cursor.execute(
+                "SELECT sql FROM sqlite_master WHERE type='table' and name=%s" % (
+                    self.connection.ops.quote_name(table_name),
+                )
+            ).fetchone()[0]
+        except TypeError:
+            # table_name is a view.
+            pass
+        else:
+            columns = {info.name for info in self.get_table_description(cursor, table_name)}
+            constraints.update(self._parse_table_constraints(table_schema, columns))
+
+        # Get the index info
+        cursor.execute("PRAGMA index_list(%s)" % self.connection.ops.quote_name(table_name))
+        for row in cursor.fetchall():
+            # SQLite 3.8.9+ has 5 columns, however older versions only give 3
+            # columns. Discard last 2 columns if there.
+            number, index, unique = row[:3]
+            cursor.execute(
+                "SELECT sql FROM sqlite_master "
+                "WHERE type='index' AND name=%s" % self.connection.ops.quote_name(index)
+            )
+            # There's at most one row.
+            sql, = cursor.fetchone() or (None,)
+            # Inline constraints are already detected in
+            # _parse_table_constraints(). The reasons to avoid fetching inline
+            # constraints from `PRAGMA index_list` are:
+            # - Inline constraints can have a different name and information
+            #   than what `PRAGMA index_list` gives.
+            # - Not all inline constraints may appear in `PRAGMA index_list`.
+            if not sql:
+                # An inline constraint
+                continue
+            # Get the index info for that index
+            cursor.execute('PRAGMA index_info(%s)' % self.connection.ops.quote_name(index))
+            for index_rank, column_rank, column in cursor.fetchall():
+                if index not in constraints:
+                    constraints[index] = {
+                        "columns": [],
+                        "primary_key": False,
+                        "unique": bool(unique),
+                        "foreign_key": None,
+                        "check": False,
+                        "index": True,
+                    }
+                constraints[index]['columns'].append(column)
+            # Add type and column orders for indexes
+            if constraints[index]['index'] and not constraints[index]['unique']:
+                # SQLite doesn't support any index type other than b-tree
+                constraints[index]['type'] = Index.suffix
+                order_info = sql.split('(')[-1].split(')')[0].split(',')
+                orders = ['DESC' if info.endswith('DESC') else 'ASC' for info in order_info]
+                constraints[index]['orders'] = orders
+        # Get the PK
+        pk_column = self.get_primary_key_column(cursor, table_name)
+        if pk_column:
+            # SQLite doesn't actually give a name to the PK constraint,
+            # so we invent one. This is fine, as the SQLite backend never
+            # deletes PK constraints by name, as you can't delete constraints
+            # in SQLite; we remake the table with a new PK instead.
+            constraints["__primary__"] = {
+                "columns": [pk_column],
+                "primary_key": True,
+                "unique": False,  # It's not actually a unique constraint.
+                "foreign_key": None,
+                "check": False,
+                "index": False,
+            }
+        constraints.update(self._get_foreign_key_constraints(cursor, table_name))
+        return constraints

venv/lib/python3.7/site-packages/django/db/migrations/__init__.py

@@ -0,0 +1,2 @@
+from .migration import Migration, swappable_dependency  # NOQA
+from .operations import *  # NOQA

venv/lib/python3.7/site-packages/django/db/migrations/exceptions.py

@@ -0,0 +1,54 @@
+from django.db.utils import DatabaseError
+
+
+class AmbiguityError(Exception):
+    """More than one migration matches a name prefix."""
+    pass
+
+
+class BadMigrationError(Exception):
+    """There's a bad migration (unreadable/bad format/etc.)."""
+    pass
+
+
+class CircularDependencyError(Exception):
+    """There's an impossible-to-resolve circular dependency."""
+    pass
+
+
+class InconsistentMigrationHistory(Exception):
+    """An applied migration has some of its dependencies not applied."""
+    pass
+
+
+class InvalidBasesError(ValueError):
+    """A model's base classes can't be resolved."""
+    pass
+
+
+class IrreversibleError(RuntimeError):
+    """An irreversible migration is about to be reversed."""
+    pass
+
+
+class NodeNotFoundError(LookupError):
+    """An attempt on a node is made that is not available in the graph."""
+
+    def __init__(self, message, node, origin=None):
+        self.message = message
+        self.origin = origin
+        self.node = node
+
+    def __str__(self):
+        return self.message
+
+    def __repr__(self):
+        return "NodeNotFoundError(%r)" % (self.node,)
+
+
+class MigrationSchemaMissing(DatabaseError):
+    pass
+
+
+class InvalidMigrationPlan(ValueError):
+    pass

venv/lib/python3.7/site-packages/django/db/migrations/executor.py

@@ -0,0 +1,376 @@
+from django.apps.registry import apps as global_apps
+from django.db import migrations, router
+
+from .exceptions import InvalidMigrationPlan
+from .loader import MigrationLoader
+from .recorder import MigrationRecorder
+from .state import ProjectState
+
+
+class MigrationExecutor:
+    """
+    End-to-end migration execution - load migrations and run them up or down
+    to a specified set of targets.
+    """
+
+    def __init__(self, connection, progress_callback=None):
+        self.connection = connection
+        self.loader = MigrationLoader(self.connection)
+        self.recorder = MigrationRecorder(self.connection)
+        self.progress_callback = progress_callback
+
+    def migration_plan(self, targets, clean_start=False):
+        """
+        Given a set of targets, return a list of (Migration instance, backwards?).
+        """
+        plan = []
+        if clean_start:
+            applied = set()
+        else:
+            applied = set(self.loader.applied_migrations)
+        for target in targets:
+            # If the target is (app_label, None), that means unmigrate everything
+            if target[1] is None:
+                for root in self.loader.graph.root_nodes():
+                    if root[0] == target[0]:
+                        for migration in self.loader.graph.backwards_plan(root):
+                            if migration in applied:
+                                plan.append((self.loader.graph.nodes[migration], True))
+                                applied.remove(migration)
+            # If the migration is already applied, do backwards mode,
+            # otherwise do forwards mode.
+            elif target in applied:
+                # Don't migrate backwards all the way to the target node (that
+                # may roll back dependencies in other apps that don't need to
+                # be rolled back); instead roll back through target's immediate
+                # child(ren) in the same app, and no further.
+                next_in_app = sorted(
+                    n for n in
+                    self.loader.graph.node_map[target].children
+                    if n[0] == target[0]
+                )
+                for node in next_in_app:
+                    for migration in self.loader.graph.backwards_plan(node):
+                        if migration in applied:
+                            plan.append((self.loader.graph.nodes[migration], True))
+                            applied.remove(migration)
+            else:
+                for migration in self.loader.graph.forwards_plan(target):
+                    if migration not in applied:
+                        plan.append((self.loader.graph.nodes[migration], False))
+                        applied.add(migration)
+        return plan
+
+    def _create_project_state(self, with_applied_migrations=False):
+        """
+        Create a project state including all the applications without
+        migrations and applied migrations if with_applied_migrations=True.
+        """
+        state = ProjectState(real_apps=list(self.loader.unmigrated_apps))
+        if with_applied_migrations:
+            # Create the forwards plan Django would follow on an empty database
+            full_plan = self.migration_plan(self.loader.graph.leaf_nodes(), clean_start=True)
+            applied_migrations = {
+                self.loader.graph.nodes[key] for key in self.loader.applied_migrations
+                if key in self.loader.graph.nodes
+            }
+            for migration, _ in full_plan:
+                if migration in applied_migrations:
+                    migration.mutate_state(state, preserve=False)
+        return state
+
+    def migrate(self, targets, plan=None, state=None, fake=False, fake_initial=False):
+        """
+        Migrate the database up to the given targets.
+
+        Django first needs to create all project states before a migration is
+        (un)applied and in a second step run all the database operations.
+        """
+        # The django_migrations table must be present to record applied
+        # migrations.
+        self.recorder.ensure_schema()
+
+        if plan is None:
+            plan = self.migration_plan(targets)
+        # Create the forwards plan Django would follow on an empty database
+        full_plan = self.migration_plan(self.loader.graph.leaf_nodes(), clean_start=True)
+
+        all_forwards = all(not backwards for mig, backwards in plan)
+        all_backwards = all(backwards for mig, backwards in plan)
+
+        if not plan:
+            if state is None:
+                # The resulting state should include applied migrations.
+                state = self._create_project_state(with_applied_migrations=True)
+        elif all_forwards == all_backwards:
+            # This should only happen if there's a mixed plan
+            raise InvalidMigrationPlan(
+                "Migration plans with both forwards and backwards migrations "
+                "are not supported. Please split your migration process into "
+                "separate plans of only forwards OR backwards migrations.",
+                plan
+            )
+        elif all_forwards:
+            if state is None:
+                # The resulting state should still include applied migrations.
+                state = self._create_project_state(with_applied_migrations=True)
+            state = self._migrate_all_forwards(state, plan, full_plan, fake=fake, fake_initial=fake_initial)
+        else:
+            # No need to check for `elif all_backwards` here, as that condition
+            # would always evaluate to true.
+            state = self._migrate_all_backwards(plan, full_plan, fake=fake)
+
+        self.check_replacements()
+
+        return state
+
+    def _migrate_all_forwards(self, state, plan, full_plan, fake, fake_initial):
+        """
+        Take a list of 2-tuples of the form (migration instance, False) and
+        apply them in the order they occur in the full_plan.
+        """
+        migrations_to_run = {m[0] for m in plan}
+        for migration, _ in full_plan:
+            if not migrations_to_run:
+                # We remove every migration that we applied from these sets so
+                # that we can bail out once the last migration has been applied
+                # and don't always run until the very end of the migration
+                # process.
+                break
+            if migration in migrations_to_run:
+                if 'apps' not in state.__dict__:
+                    if self.progress_callback:
+                        self.progress_callback("render_start")
+                    state.apps  # Render all -- performance critical
+                    if self.progress_callback:
+                        self.progress_callback("render_success")
+                state = self.apply_migration(state, migration, fake=fake, fake_initial=fake_initial)
+                migrations_to_run.remove(migration)
+
+        return state
+
+    def _migrate_all_backwards(self, plan, full_plan, fake):
+        """
+        Take a list of 2-tuples of the form (migration instance, True) and
+        unapply them in reverse order they occur in the full_plan.
+
+        Since unapplying a migration requires the project state prior to that
+        migration, Django will compute the migration states before each of them
+        in a first run over the plan and then unapply them in a second run over
+        the plan.
+        """
+        migrations_to_run = {m[0] for m in plan}
+        # Holds all migration states prior to the migrations being unapplied
+        states = {}
+        state = self._create_project_state()
+        applied_migrations = {
+            self.loader.graph.nodes[key] for key in self.loader.applied_migrations
+            if key in self.loader.graph.nodes
+        }
+        if self.progress_callback:
+            self.progress_callback("render_start")
+        for migration, _ in full_plan:
+            if not migrations_to_run:
+                # We remove every migration that we applied from this set so
+                # that we can bail out once the last migration has been applied
+                # and don't always run until the very end of the migration
+                # process.
+                break
+            if migration in migrations_to_run:
+                if 'apps' not in state.__dict__:
+                    state.apps  # Render all -- performance critical
+                # The state before this migration
+                states[migration] = state
+                # The old state keeps as-is, we continue with the new state
+                state = migration.mutate_state(state, preserve=True)
+                migrations_to_run.remove(migration)
+            elif migration in applied_migrations:
+                # Only mutate the state if the migration is actually applied
+                # to make sure the resulting state doesn't include changes
+                # from unrelated migrations.
+                migration.mutate_state(state, preserve=False)
+        if self.progress_callback:
+            self.progress_callback("render_success")
+
+        for migration, _ in plan:
+            self.unapply_migration(states[migration], migration, fake=fake)
+            applied_migrations.remove(migration)
+
+        # Generate the post migration state by starting from the state before
+        # the last migration is unapplied and mutating it to include all the
+        # remaining applied migrations.
+        last_unapplied_migration = plan[-1][0]
+        state = states[last_unapplied_migration]
+        for index, (migration, _) in enumerate(full_plan):
+            if migration == last_unapplied_migration:
+                for migration, _ in full_plan[index:]:
+                    if migration in applied_migrations:
+                        migration.mutate_state(state, preserve=False)
+                break
+
+        return state
+
+    def collect_sql(self, plan):
+        """
+        Take a migration plan and return a list of collected SQL statements
+        that represent the best-efforts version of that plan.
+        """
+        statements = []
+        state = None
+        for migration, backwards in plan:
+            with self.connection.schema_editor(collect_sql=True, atomic=migration.atomic) as schema_editor:
+                if state is None:
+                    state = self.loader.project_state((migration.app_label, migration.name), at_end=False)
+                if not backwards:
+                    state = migration.apply(state, schema_editor, collect_sql=True)
+                else:
+                    state = migration.unapply(state, schema_editor, collect_sql=True)
+            statements.extend(schema_editor.collected_sql)
+        return statements
+
+    def apply_migration(self, state, migration, fake=False, fake_initial=False):
+        """Run a migration forwards."""
+        migration_recorded = False
+        if self.progress_callback:
+            self.progress_callback("apply_start", migration, fake)
+        if not fake:
+            if fake_initial:
+                # Test to see if this is an already-applied initial migration
+                applied, state = self.detect_soft_applied(state, migration)
+                if applied:
+                    fake = True
+            if not fake:
+                # Alright, do it normally
+                with self.connection.schema_editor(atomic=migration.atomic) as schema_editor:
+                    state = migration.apply(state, schema_editor)
+                    self.record_migration(migration)
+                    migration_recorded = True
+        if not migration_recorded:
+            self.record_migration(migration)
+        # Report progress
+        if self.progress_callback:
+            self.progress_callback("apply_success", migration, fake)
+        return state
+
+    def record_migration(self, migration):
+        # For replacement migrations, record individual statuses
+        if migration.replaces:
+            for app_label, name in migration.replaces:
+                self.recorder.record_applied(app_label, name)
+        else:
+            self.recorder.record_applied(migration.app_label, migration.name)
+
+    def unapply_migration(self, state, migration, fake=False):
+        """Run a migration backwards."""
+        if self.progress_callback:
+            self.progress_callback("unapply_start", migration, fake)
+        if not fake:
+            with self.connection.schema_editor(atomic=migration.atomic) as schema_editor:
+                state = migration.unapply(state, schema_editor)
+        # For replacement migrations, record individual statuses
+        if migration.replaces:
+            for app_label, name in migration.replaces:
+                self.recorder.record_unapplied(app_label, name)
+        else:
+            self.recorder.record_unapplied(migration.app_label, migration.name)
+        # Report progress
+        if self.progress_callback:
+            self.progress_callback("unapply_success", migration, fake)
+        return state
+
+    def check_replacements(self):
+        """
+        Mark replacement migrations applied if their replaced set all are.
+
+        Do this unconditionally on every migrate, rather than just when
+        migrations are applied or unapplied, to correctly handle the case
+        when a new squash migration is pushed to a deployment that already had
+        all its replaced migrations applied. In this case no new migration will
+        be applied, but the applied state of the squashed migration must be
+        maintained.
+        """
+        applied = self.recorder.applied_migrations()
+        for key, migration in self.loader.replacements.items():
+            all_applied = all(m in applied for m in migration.replaces)
+            if all_applied and key not in applied:
+                self.recorder.record_applied(*key)
+
+    def detect_soft_applied(self, project_state, migration):
+        """
+        Test whether a migration has been implicitly applied - that the
+        tables or columns it would create exist. This is intended only for use
+        on initial migrations (as it only looks for CreateModel and AddField).
+        """
+        def should_skip_detecting_model(migration, model):
+            """
+            No need to detect tables for proxy models, unmanaged models, or
+            models that can't be migrated on the current database.
+            """
+            return (
+                model._meta.proxy or not model._meta.managed or not
+                router.allow_migrate(
+                    self.connection.alias, migration.app_label,
+                    model_name=model._meta.model_name,
+                )
+            )
+
+        if migration.initial is None:
+            # Bail if the migration isn't the first one in its app
+            if any(app == migration.app_label for app, name in migration.dependencies):
+                return False, project_state
+        elif migration.initial is False:
+            # Bail if it's NOT an initial migration
+            return False, project_state
+
+        if project_state is None:
+            after_state = self.loader.project_state((migration.app_label, migration.name), at_end=True)
+        else:
+            after_state = migration.mutate_state(project_state)
+        apps = after_state.apps
+        found_create_model_migration = False
+        found_add_field_migration = False
+        with self.connection.cursor() as cursor:
+            existing_table_names = self.connection.introspection.table_names(cursor)
+        # Make sure all create model and add field operations are done
+        for operation in migration.operations:
+            if isinstance(operation, migrations.CreateModel):
+                model = apps.get_model(migration.app_label, operation.name)
+                if model._meta.swapped:
+                    # We have to fetch the model to test with from the
+                    # main app cache, as it's not a direct dependency.
+                    model = global_apps.get_model(model._meta.swapped)
+                if should_skip_detecting_model(migration, model):
+                    continue
+                if model._meta.db_table not in existing_table_names:
+                    return False, project_state
+                found_create_model_migration = True
+            elif isinstance(operation, migrations.AddField):
+                model = apps.get_model(migration.app_label, operation.model_name)
+                if model._meta.swapped:
+                    # We have to fetch the model to test with from the
+                    # main app cache, as it's not a direct dependency.
+                    model = global_apps.get_model(model._meta.swapped)
+                if should_skip_detecting_model(migration, model):
+                    continue
+
+                table = model._meta.db_table
+                field = model._meta.get_field(operation.name)
+
+                # Handle implicit many-to-many tables created by AddField.
+                if field.many_to_many:
+                    if field.remote_field.through._meta.db_table not in existing_table_names:
+                        return False, project_state
+                    else:
+                        found_add_field_migration = True
+                        continue
+
+                column_names = [
+                    column.name for column in
+                    self.connection.introspection.get_table_description(self.connection.cursor(), table)
+                ]
+                if field.column not in column_names:
+                    return False, project_state
+                found_add_field_migration = True
+        # If we get this far and we found at least one CreateModel or AddField migration,
+        # the migration is considered implicitly applied.
+        return (found_create_model_migration or found_add_field_migration), after_state

venv/lib/python3.7/site-packages/django/db/migrations/questioner.py

@@ -0,0 +1,239 @@
+import datetime
+import importlib
+import os
+import sys
+
+from django.apps import apps
+from django.db.models.fields import NOT_PROVIDED
+from django.utils import timezone
+
+from .loader import MigrationLoader
+
+
+class MigrationQuestioner:
+    """
+    Give the autodetector responses to questions it might have.
+    This base class has a built-in noninteractive mode, but the
+    interactive subclass is what the command-line arguments will use.
+    """
+
+    def __init__(self, defaults=None, specified_apps=None, dry_run=None):
+        self.defaults = defaults or {}
+        self.specified_apps = specified_apps or set()
+        self.dry_run = dry_run
+
+    def ask_initial(self, app_label):
+        """Should we create an initial migration for the app?"""
+        # If it was specified on the command line, definitely true
+        if app_label in self.specified_apps:
+            return True
+        # Otherwise, we look to see if it has a migrations module
+        # without any Python files in it, apart from __init__.py.
+        # Apps from the new app template will have these; the Python
+        # file check will ensure we skip South ones.
+        try:
+            app_config = apps.get_app_config(app_label)
+        except LookupError:         # It's a fake app.
+            return self.defaults.get("ask_initial", False)
+        migrations_import_path, _ = MigrationLoader.migrations_module(app_config.label)
+        if migrations_import_path is None:
+            # It's an application with migrations disabled.
+            return self.defaults.get("ask_initial", False)
+        try:
+            migrations_module = importlib.import_module(migrations_import_path)
+        except ImportError:
+            return self.defaults.get("ask_initial", False)
+        else:
+            # getattr() needed on PY36 and older (replace with attribute access).
+            if getattr(migrations_module, "__file__", None):
+                filenames = os.listdir(os.path.dirname(migrations_module.__file__))
+            elif hasattr(migrations_module, "__path__"):
+                if len(migrations_module.__path__) > 1:
+                    return False
+                filenames = os.listdir(list(migrations_module.__path__)[0])
+            return not any(x.endswith(".py") for x in filenames if x != "__init__.py")
+
+    def ask_not_null_addition(self, field_name, model_name):
+        """Adding a NOT NULL field to a model."""
+        # None means quit
+        return None
+
+    def ask_not_null_alteration(self, field_name, model_name):
+        """Changing a NULL field to NOT NULL."""
+        # None means quit
+        return None
+
+    def ask_rename(self, model_name, old_name, new_name, field_instance):
+        """Was this field really renamed?"""
+        return self.defaults.get("ask_rename", False)
+
+    def ask_rename_model(self, old_model_state, new_model_state):
+        """Was this model really renamed?"""
+        return self.defaults.get("ask_rename_model", False)
+
+    def ask_merge(self, app_label):
+        """Do you really want to merge these migrations?"""
+        return self.defaults.get("ask_merge", False)
+
+    def ask_auto_now_add_addition(self, field_name, model_name):
+        """Adding an auto_now_add field to a model."""
+        # None means quit
+        return None
+
+
+class InteractiveMigrationQuestioner(MigrationQuestioner):
+
+    def _boolean_input(self, question, default=None):
+        result = input("%s " % question)
+        if not result and default is not None:
+            return default
+        while not result or result[0].lower() not in "yn":
+            result = input("Please answer yes or no: ")
+        return result[0].lower() == "y"
+
+    def _choice_input(self, question, choices):
+        print(question)
+        for i, choice in enumerate(choices):
+            print(" %s) %s" % (i + 1, choice))
+        result = input("Select an option: ")
+        while True:
+            try:
+                value = int(result)
+            except ValueError:
+                pass
+            else:
+                if 0 < value <= len(choices):
+                    return value
+            result = input("Please select a valid option: ")
+
+    def _ask_default(self, default=''):
+        """
+        Prompt for a default value.
+
+        The ``default`` argument allows providing a custom default value (as a
+        string) which will be shown to the user and used as the return value
+        if the user doesn't provide any other input.
+        """
+        print("Please enter the default value now, as valid Python")
+        if default:
+            print(
+                "You can accept the default '{}' by pressing 'Enter' or you "
+                "can provide another value.".format(default)
+            )
+        print("The datetime and django.utils.timezone modules are available, so you can do e.g. timezone.now")
+        print("Type 'exit' to exit this prompt")
+        while True:
+            if default:
+                prompt = "[default: {}] >>> ".format(default)
+            else:
+                prompt = ">>> "
+            code = input(prompt)
+            if not code and default:
+                code = default
+            if not code:
+                print("Please enter some code, or 'exit' (with no quotes) to exit.")
+            elif code == "exit":
+                sys.exit(1)
+            else:
+                try:
+                    return eval(code, {}, {'datetime': datetime, 'timezone': timezone})
+                except (SyntaxError, NameError) as e:
+                    print("Invalid input: %s" % e)
+
+    def ask_not_null_addition(self, field_name, model_name):
+        """Adding a NOT NULL field to a model."""
+        if not self.dry_run:
+            choice = self._choice_input(
+                "You are trying to add a non-nullable field '%s' to %s without a default; "
+                "we can't do that (the database needs something to populate existing rows).\n"
+                "Please select a fix:" % (field_name, model_name),
+                [
+                    ("Provide a one-off default now (will be set on all existing "
+                     "rows with a null value for this column)"),
+                    "Quit, and let me add a default in models.py",
+                ]
+            )
+            if choice == 2:
+                sys.exit(3)
+            else:
+                return self._ask_default()
+        return None
+
+    def ask_not_null_alteration(self, field_name, model_name):
+        """Changing a NULL field to NOT NULL."""
+        if not self.dry_run:
+            choice = self._choice_input(
+                "You are trying to change the nullable field '%s' on %s to non-nullable "
+                "without a default; we can't do that (the database needs something to "
+                "populate existing rows).\n"
+                "Please select a fix:" % (field_name, model_name),
+                [
+                    ("Provide a one-off default now (will be set on all existing "
+                     "rows with a null value for this column)"),
+                    ("Ignore for now, and let me handle existing rows with NULL myself "
+                     "(e.g. because you added a RunPython or RunSQL operation to handle "
+                     "NULL values in a previous data migration)"),
+                    "Quit, and let me add a default in models.py",
+                ]
+            )
+            if choice == 2:
+                return NOT_PROVIDED
+            elif choice == 3:
+                sys.exit(3)
+            else:
+                return self._ask_default()
+        return None
+
+    def ask_rename(self, model_name, old_name, new_name, field_instance):
+        """Was this field really renamed?"""
+        msg = "Did you rename %s.%s to %s.%s (a %s)? [y/N]"
+        return self._boolean_input(msg % (model_name, old_name, model_name, new_name,
+                                          field_instance.__class__.__name__), False)
+
+    def ask_rename_model(self, old_model_state, new_model_state):
+        """Was this model really renamed?"""
+        msg = "Did you rename the %s.%s model to %s? [y/N]"
+        return self._boolean_input(msg % (old_model_state.app_label, old_model_state.name,
+                                          new_model_state.name), False)
+
+    def ask_merge(self, app_label):
+        return self._boolean_input(
+            "\nMerging will only work if the operations printed above do not conflict\n" +
+            "with each other (working on different fields or models)\n" +
+            "Do you want to merge these migration branches? [y/N]",
+            False,
+        )
+
+    def ask_auto_now_add_addition(self, field_name, model_name):
+        """Adding an auto_now_add field to a model."""
+        if not self.dry_run:
+            choice = self._choice_input(
+                "You are trying to add the field '{}' with 'auto_now_add=True' "
+                "to {} without a default; the database needs something to "
+                "populate existing rows.\n".format(field_name, model_name),
+                [
+                    "Provide a one-off default now (will be set on all "
+                    "existing rows)",
+                    "Quit, and let me add a default in models.py",
+                ]
+            )
+            if choice == 2:
+                sys.exit(3)
+            else:
+                return self._ask_default(default='timezone.now')
+        return None
+
+
+class NonInteractiveMigrationQuestioner(MigrationQuestioner):
+
+    def ask_not_null_addition(self, field_name, model_name):
+        # We can't ask the user, so act like the user aborted.
+        sys.exit(3)
+
+    def ask_not_null_alteration(self, field_name, model_name):
+        # We can't ask the user, so set as not provided.
+        return NOT_PROVIDED
+
+    def ask_auto_now_add_addition(self, field_name, model_name):
+        # We can't ask the user, so act like the user aborted.
+        sys.exit(3)

venv/lib/python3.7/site-packages/django/db/migrations/recorder.py

@@ -0,0 +1,92 @@
+from django.apps.registry import Apps
+from django.db import models
+from django.db.utils import DatabaseError
+from django.utils.decorators import classproperty
+from django.utils.timezone import now
+
+from .exceptions import MigrationSchemaMissing
+
+
+class MigrationRecorder:
+    """
+    Deal with storing migration records in the database.
+
+    Because this table is actually itself used for dealing with model
+    creation, it's the one thing we can't do normally via migrations.
+    We manually handle table creation/schema updating (using schema backend)
+    and then have a floating model to do queries with.
+
+    If a migration is unapplied its row is removed from the table. Having
+    a row in the table always means a migration is applied.
+    """
+    _migration_class = None
+
+    @classproperty
+    def Migration(cls):
+        """
+        Lazy load to avoid AppRegistryNotReady if installed apps import
+        MigrationRecorder.
+        """
+        if cls._migration_class is None:
+            class Migration(models.Model):
+                app = models.CharField(max_length=255)
+                name = models.CharField(max_length=255)
+                applied = models.DateTimeField(default=now)
+
+                class Meta:
+                    apps = Apps()
+                    app_label = 'migrations'
+                    db_table = 'django_migrations'
+
+                def __str__(self):
+                    return 'Migration %s for %s' % (self.name, self.app)
+
+            cls._migration_class = Migration
+        return cls._migration_class
+
+    def __init__(self, connection):
+        self.connection = connection
+
+    @property
+    def migration_qs(self):
+        return self.Migration.objects.using(self.connection.alias)
+
+    def has_table(self):
+        """Return True if the django_migrations table exists."""
+        return self.Migration._meta.db_table in self.connection.introspection.table_names(self.connection.cursor())
+
+    def ensure_schema(self):
+        """Ensure the table exists and has the correct schema."""
+        # If the table's there, that's fine - we've never changed its schema
+        # in the codebase.
+        if self.has_table():
+            return
+        # Make the table
+        try:
+            with self.connection.schema_editor() as editor:
+                editor.create_model(self.Migration)
+        except DatabaseError as exc:
+            raise MigrationSchemaMissing("Unable to create the django_migrations table (%s)" % exc)
+
+    def applied_migrations(self):
+        """Return a set of (app, name) of applied migrations."""
+        if self.has_table():
+            return {tuple(x) for x in self.migration_qs.values_list('app', 'name')}
+        else:
+            # If the django_migrations table doesn't exist, then no migrations
+            # are applied.
+            return set()
+
+    def record_applied(self, app, name):
+        """Record that a migration was applied."""
+        self.ensure_schema()
+        self.migration_qs.create(app=app, name=name)
+
+    def record_unapplied(self, app, name):
+        """Record that a migration was unapplied."""
+        self.ensure_schema()
+        self.migration_qs.filter(app=app, name=name).delete()
+
+    def flush(self):
+        """Delete all migration records. Useful for testing migrations."""
+        self.migration_qs.all().delete()

venv/lib/python3.7/site-packages/django/db/migrations/state.py

@@ -0,0 +1,612 @@
+import copy
+from collections import OrderedDict
+from contextlib import contextmanager
+
+from django.apps import AppConfig
+from django.apps.registry import Apps, apps as global_apps
+from django.conf import settings
+from django.db import models
+from django.db.models.fields.proxy import OrderWrt
+from django.db.models.fields.related import RECURSIVE_RELATIONSHIP_CONSTANT
+from django.db.models.options import DEFAULT_NAMES, normalize_together
+from django.db.models.utils import make_model_tuple
+from django.utils.functional import cached_property
+from django.utils.module_loading import import_string
+from django.utils.version import get_docs_version
+
+from .exceptions import InvalidBasesError
+
+
+def _get_app_label_and_model_name(model, app_label=''):
+    if isinstance(model, str):
+        split = model.split('.', 1)
+        return tuple(split) if len(split) == 2 else (app_label, split[0])
+    else:
+        return model._meta.app_label, model._meta.model_name
+
+
+def _get_related_models(m):
+    """Return all models that have a direct relationship to the given model."""
+    related_models = [
+        subclass for subclass in m.__subclasses__()
+        if issubclass(subclass, models.Model)
+    ]
+    related_fields_models = set()
+    for f in m._meta.get_fields(include_parents=True, include_hidden=True):
+        if f.is_relation and f.related_model is not None and not isinstance(f.related_model, str):
+            related_fields_models.add(f.model)
+            related_models.append(f.related_model)
+    # Reverse accessors of foreign keys to proxy models are attached to their
+    # concrete proxied model.
+    opts = m._meta
+    if opts.proxy and m in related_fields_models:
+        related_models.append(opts.concrete_model)
+    return related_models
+
+
+def get_related_models_tuples(model):
+    """
+    Return a list of typical (app_label, model_name) tuples for all related
+    models for the given model.
+    """
+    return {
+        (rel_mod._meta.app_label, rel_mod._meta.model_name)
+        for rel_mod in _get_related_models(model)
+    }
+
+
+def get_related_models_recursive(model):
+    """
+    Return all models that have a direct or indirect relationship
+    to the given model.
+
+    Relationships are either defined by explicit relational fields, like
+    ForeignKey, ManyToManyField or OneToOneField, or by inheriting from another
+    model (a superclass is related to its subclasses, but not vice versa). Note,
+    however, that a model inheriting from a concrete model is also related to
+    its superclass through the implicit *_ptr OneToOneField on the subclass.
+    """
+    seen = set()
+    queue = _get_related_models(model)
+    for rel_mod in queue:
+        rel_app_label, rel_model_name = rel_mod._meta.app_label, rel_mod._meta.model_name
+        if (rel_app_label, rel_model_name) in seen:
+            continue
+        seen.add((rel_app_label, rel_model_name))
+        queue.extend(_get_related_models(rel_mod))
+    return seen - {(model._meta.app_label, model._meta.model_name)}
+
+
+class ProjectState:
+    """
+    Represent the entire project's overall state. This is the item that is
+    passed around - do it here rather than at the app level so that cross-app
+    FKs/etc. resolve properly.
+    """
+
+    def __init__(self, models=None, real_apps=None):
+        self.models = models or {}
+        # Apps to include from main registry, usually unmigrated ones
+        self.real_apps = real_apps or []
+        self.is_delayed = False
+
+    def add_model(self, model_state):
+        app_label, model_name = model_state.app_label, model_state.name_lower
+        self.models[(app_label, model_name)] = model_state
+        if 'apps' in self.__dict__:  # hasattr would cache the property
+            self.reload_model(app_label, model_name)
+
+    def remove_model(self, app_label, model_name):
+        del self.models[app_label, model_name]
+        if 'apps' in self.__dict__:  # hasattr would cache the property
+            self.apps.unregister_model(app_label, model_name)
+            # Need to do this explicitly since unregister_model() doesn't clear
+            # the cache automatically (#24513)
+            self.apps.clear_cache()
+
+    def _find_reload_model(self, app_label, model_name, delay=False):
+        if delay:
+            self.is_delayed = True
+
+        related_models = set()
+
+        try:
+            old_model = self.apps.get_model(app_label, model_name)
+        except LookupError:
+            pass
+        else:
+            # Get all relations to and from the old model before reloading,
+            # as _meta.apps may change
+            if delay:
+                related_models = get_related_models_tuples(old_model)
+            else:
+                related_models = get_related_models_recursive(old_model)
+
+        # Get all outgoing references from the model to be rendered
+        model_state = self.models[(app_label, model_name)]
+        # Directly related models are the models pointed to by ForeignKeys,
+        # OneToOneFields, and ManyToManyFields.
+        direct_related_models = set()
+        for name, field in model_state.fields:
+            if field.is_relation:
+                if field.remote_field.model == RECURSIVE_RELATIONSHIP_CONSTANT:
+                    continue
+                rel_app_label, rel_model_name = _get_app_label_and_model_name(field.related_model, app_label)
+                direct_related_models.add((rel_app_label, rel_model_name.lower()))
+
+        # For all direct related models recursively get all related models.
+        related_models.update(direct_related_models)
+        for rel_app_label, rel_model_name in direct_related_models:
+            try:
+                rel_model = self.apps.get_model(rel_app_label, rel_model_name)
+            except LookupError:
+                pass
+            else:
+                if delay:
+                    related_models.update(get_related_models_tuples(rel_model))
+                else:
+                    related_models.update(get_related_models_recursive(rel_model))
+
+        # Include the model itself
+        related_models.add((app_label, model_name))
+
+        return related_models
+
+    def reload_model(self, app_label, model_name, delay=False):
+        if 'apps' in self.__dict__:  # hasattr would cache the property
+            related_models = self._find_reload_model(app_label, model_name, delay)
+            self._reload(related_models)
+
+    def reload_models(self, models, delay=True):
+        if 'apps' in self.__dict__:  # hasattr would cache the property
+            related_models = set()
+            for app_label, model_name in models:
+                related_models.update(self._find_reload_model(app_label, model_name, delay))
+            self._reload(related_models)
+
+    def _reload(self, related_models):
+        # Unregister all related models
+        with self.apps.bulk_update():
+            for rel_app_label, rel_model_name in related_models:
+                self.apps.unregister_model(rel_app_label, rel_model_name)
+
+        states_to_be_rendered = []
+        # Gather all models states of those models that will be rerendered.
+        # This includes:
+        # 1. All related models of unmigrated apps
+        for model_state in self.apps.real_models:
+            if (model_state.app_label, model_state.name_lower) in related_models:
+                states_to_be_rendered.append(model_state)
+
+        # 2. All related models of migrated apps
+        for rel_app_label, rel_model_name in related_models:
+            try:
+                model_state = self.models[rel_app_label, rel_model_name]
+            except KeyError:
+                pass
+            else:
+                states_to_be_rendered.append(model_state)
+
+        # Render all models
+        self.apps.render_multiple(states_to_be_rendered)
+
+    def clone(self):
+        """Return an exact copy of this ProjectState."""
+        new_state = ProjectState(
+            models={k: v.clone() for k, v in self.models.items()},
+            real_apps=self.real_apps,
+        )
+        if 'apps' in self.__dict__:
+            new_state.apps = self.apps.clone()
+        new_state.is_delayed = self.is_delayed
+        return new_state
+
+    def clear_delayed_apps_cache(self):
+        if self.is_delayed and 'apps' in self.__dict__:
+            del self.__dict__['apps']
+
+    @cached_property
+    def apps(self):
+        return StateApps(self.real_apps, self.models)
+
+    @property
+    def concrete_apps(self):
+        self.apps = StateApps(self.real_apps, self.models, ignore_swappable=True)
+        return self.apps
+
+    @classmethod
+    def from_apps(cls, apps):
+        """Take an Apps and return a ProjectState matching it."""
+        app_models = {}
+        for model in apps.get_models(include_swapped=True):
+            model_state = ModelState.from_model(model)
+            app_models[(model_state.app_label, model_state.name_lower)] = model_state
+        return cls(app_models)
+
+    def __eq__(self, other):
+        return self.models == other.models and set(self.real_apps) == set(other.real_apps)
+
+
+class AppConfigStub(AppConfig):
+    """Stub of an AppConfig. Only provides a label and a dict of models."""
+    # Not used, but required by AppConfig.__init__
+    path = ''
+
+    def __init__(self, label):
+        self.label = label
+        # App-label and app-name are not the same thing, so technically passing
+        # in the label here is wrong. In practice, migrations don't care about
+        # the app name, but we need something unique, and the label works fine.
+        super().__init__(label, None)
+
+    def import_models(self):
+        self.models = self.apps.all_models[self.label]
+
+
+class StateApps(Apps):
+    """
+    Subclass of the global Apps registry class to better handle dynamic model
+    additions and removals.
+    """
+    def __init__(self, real_apps, models, ignore_swappable=False):
+        # Any apps in self.real_apps should have all their models included
+        # in the render. We don't use the original model instances as there
+        # are some variables that refer to the Apps object.
+        # FKs/M2Ms from real apps are also not included as they just
+        # mess things up with partial states (due to lack of dependencies)
+        self.real_models = []
+        for app_label in real_apps:
+            app = global_apps.get_app_config(app_label)
+            for model in app.get_models():
+                self.real_models.append(ModelState.from_model(model, exclude_rels=True))
+        # Populate the app registry with a stub for each application.
+        app_labels = {model_state.app_label for model_state in models.values()}
+        app_configs = [AppConfigStub(label) for label in sorted([*real_apps, *app_labels])]
+        super().__init__(app_configs)
+
+        # These locks get in the way of copying as implemented in clone(),
+        # which is called whenever Django duplicates a StateApps before
+        # updating it.
+        self._lock = None
+        self.ready_event = None
+
+        self.render_multiple([*models.values(), *self.real_models])
+
+        # There shouldn't be any operations pending at this point.
+        from django.core.checks.model_checks import _check_lazy_references
+        ignore = {make_model_tuple(settings.AUTH_USER_MODEL)} if ignore_swappable else set()
+        errors = _check_lazy_references(self, ignore=ignore)
+        if errors:
+            raise ValueError("\n".join(error.msg for error in errors))
+
+    @contextmanager
+    def bulk_update(self):
+        # Avoid clearing each model's cache for each change. Instead, clear
+        # all caches when we're finished updating the model instances.
+        ready = self.ready
+        self.ready = False
+        try:
+            yield
+        finally:
+            self.ready = ready
+            self.clear_cache()
+
+    def render_multiple(self, model_states):
+        # We keep trying to render the models in a loop, ignoring invalid
+        # base errors, until the size of the unrendered models doesn't
+        # decrease by at least one, meaning there's a base dependency loop/
+        # missing base.
+        if not model_states:
+            return
+        # Prevent that all model caches are expired for each render.
+        with self.bulk_update():
+            unrendered_models = model_states
+            while unrendered_models:
+                new_unrendered_models = []
+                for model in unrendered_models:
+                    try:
+                        model.render(self)
+                    except InvalidBasesError:
+                        new_unrendered_models.append(model)
+                if len(new_unrendered_models) == len(unrendered_models):
+                    raise InvalidBasesError(
+                        "Cannot resolve bases for %r\nThis can happen if you are inheriting models from an "
+                        "app with migrations (e.g. contrib.auth)\n in an app with no migrations; see "
+                        "https://docs.djangoproject.com/en/%s/topics/migrations/#dependencies "
+                        "for more" % (new_unrendered_models, get_docs_version())
+                    )
+                unrendered_models = new_unrendered_models
+
+    def clone(self):
+        """Return a clone of this registry."""
+        clone = StateApps([], {})
+        clone.all_models = copy.deepcopy(self.all_models)
+        clone.app_configs = copy.deepcopy(self.app_configs)
+        # Set the pointer to the correct app registry.
+        for app_config in clone.app_configs.values():
+            app_config.apps = clone
+        # No need to actually clone them, they'll never change
+        clone.real_models = self.real_models
+        return clone
+
+    def register_model(self, app_label, model):
+        self.all_models[app_label][model._meta.model_name] = model
+        if app_label not in self.app_configs:
+            self.app_configs[app_label] = AppConfigStub(app_label)
+            self.app_configs[app_label].apps = self
+            self.app_configs[app_label].models = OrderedDict()
+        self.app_configs[app_label].models[model._meta.model_name] = model
+        self.do_pending_operations(model)
+        self.clear_cache()
+
+    def unregister_model(self, app_label, model_name):
+        try:
+            del self.all_models[app_label][model_name]
+            del self.app_configs[app_label].models[model_name]
+        except KeyError:
+            pass
+
+
+class ModelState:
+    """
+    Represent a Django Model. Don't use the actual Model class as it's not
+    designed to have its options changed - instead, mutate this one and then
+    render it into a Model as required.
+
+    Note that while you are allowed to mutate .fields, you are not allowed
+    to mutate the Field instances inside there themselves - you must instead
+    assign new ones, as these are not detached during a clone.
+    """
+
+    def __init__(self, app_label, name, fields, options=None, bases=None, managers=None):
+        self.app_label = app_label
+        self.name = name
+        self.fields = fields
+        self.options = options or {}
+        self.options.setdefault('indexes', [])
+        self.options.setdefault('constraints', [])
+        self.bases = bases or (models.Model,)
+        self.managers = managers or []
+        # Sanity-check that fields is NOT a dict. It must be ordered.
+        if isinstance(self.fields, dict):
+            raise ValueError("ModelState.fields cannot be a dict - it must be a list of 2-tuples.")
+        for name, field in fields:
+            # Sanity-check that fields are NOT already bound to a model.
+            if hasattr(field, 'model'):
+                raise ValueError(
+                    'ModelState.fields cannot be bound to a model - "%s" is.' % name
+                )
+            # Sanity-check that relation fields are NOT referring to a model class.
+            if field.is_relation and hasattr(field.related_model, '_meta'):
+                raise ValueError(
+                    'ModelState.fields cannot refer to a model class - "%s.to" does. '
+                    'Use a string reference instead.' % name
+                )
+            if field.many_to_many and hasattr(field.remote_field.through, '_meta'):
+                raise ValueError(
+                    'ModelState.fields cannot refer to a model class - "%s.through" does. '
+                    'Use a string reference instead.' % name
+                )
+        # Sanity-check that indexes have their name set.
+        for index in self.options['indexes']:
+            if not index.name:
+                raise ValueError(
+                    "Indexes passed to ModelState require a name attribute. "
+                    "%r doesn't have one." % index
+                )
+
+    @cached_property
+    def name_lower(self):
+        return self.name.lower()
+
+    @classmethod
+    def from_model(cls, model, exclude_rels=False):
+        """Given a model, return a ModelState representing it."""
+        # Deconstruct the fields
+        fields = []
+        for field in model._meta.local_fields:
+            if getattr(field, "remote_field", None) and exclude_rels:
+                continue
+            if isinstance(field, OrderWrt):
+                continue
+            name = field.name
+            try:
+                fields.append((name, field.clone()))
+            except TypeError as e:
+                raise TypeError("Couldn't reconstruct field %s on %s: %s" % (
+                    name,
+                    model._meta.label,
+                    e,
+                ))
+        if not exclude_rels:
+            for field in model._meta.local_many_to_many:
+                name = field.name
+                try:
+                    fields.append((name, field.clone()))
+                except TypeError as e:
+                    raise TypeError("Couldn't reconstruct m2m field %s on %s: %s" % (
+                        name,
+                        model._meta.object_name,
+                        e,
+                    ))
+        # Extract the options
+        options = {}
+        for name in DEFAULT_NAMES:
+            # Ignore some special options
+            if name in ["apps", "app_label"]:
+                continue
+            elif name in model._meta.original_attrs:
+                if name == "unique_together":
+                    ut = model._meta.original_attrs["unique_together"]
+                    options[name] = set(normalize_together(ut))
+                elif name == "index_together":
+                    it = model._meta.original_attrs["index_together"]
+                    options[name] = set(normalize_together(it))
+                elif name == "indexes":
+                    indexes = [idx.clone() for idx in model._meta.indexes]
+                    for index in indexes:
+                        if not index.name:
+                            index.set_name_with_model(model)
+                    options['indexes'] = indexes
+                elif name == 'constraints':
+                    options['constraints'] = [con.clone() for con in model._meta.constraints]
+                else:
+                    options[name] = model._meta.original_attrs[name]
+        # If we're ignoring relationships, remove all field-listing model
+        # options (that option basically just means "make a stub model")
+        if exclude_rels:
+            for key in ["unique_together", "index_together", "order_with_respect_to"]:
+                if key in options:
+                    del options[key]
+        # Private fields are ignored, so remove options that refer to them.
+        elif options.get('order_with_respect_to') in {field.name for field in model._meta.private_fields}:
+            del options['order_with_respect_to']
+
+        def flatten_bases(model):
+            bases = []
+            for base in model.__bases__:
+                if hasattr(base, "_meta") and base._meta.abstract:
+                    bases.extend(flatten_bases(base))
+                else:
+                    bases.append(base)
+            return bases
+
+        # We can't rely on __mro__ directly because we only want to flatten
+        # abstract models and not the whole tree. However by recursing on
+        # __bases__ we may end up with duplicates and ordering issues, we
+        # therefore discard any duplicates and reorder the bases according
+        # to their index in the MRO.
+        flattened_bases = sorted(set(flatten_bases(model)), key=lambda x: model.__mro__.index(x))
+
+        # Make our record
+        bases = tuple(
+            (
+                base._meta.label_lower
+                if hasattr(base, "_meta") else
+                base
+            )
+            for base in flattened_bases
+        )
+        # Ensure at least one base inherits from models.Model
+        if not any((isinstance(base, str) or issubclass(base, models.Model)) for base in bases):
+            bases = (models.Model,)
+
+        managers = []
+        manager_names = set()
+        default_manager_shim = None
+        for manager in model._meta.managers:
+            if manager.name in manager_names:
+                # Skip overridden managers.
+                continue
+            elif manager.use_in_migrations:
+                # Copy managers usable in migrations.
+                new_manager = copy.copy(manager)
+                new_manager._set_creation_counter()
+            elif manager is model._base_manager or manager is model._default_manager:
+                # Shim custom managers used as default and base managers.
+                new_manager = models.Manager()
+                new_manager.model = manager.model
+                new_manager.name = manager.name
+                if manager is model._default_manager:
+                    default_manager_shim = new_manager
+            else:
+                continue
+            manager_names.add(manager.name)
+            managers.append((manager.name, new_manager))
+
+        # Ignore a shimmed default manager called objects if it's the only one.
+        if managers == [('objects', default_manager_shim)]:
+            managers = []
+
+        # Construct the new ModelState
+        return cls(
+            model._meta.app_label,
+            model._meta.object_name,
+            fields,
+            options,
+            bases,
+            managers,
+        )
+
+    def construct_managers(self):
+        """Deep-clone the managers using deconstruction."""
+        # Sort all managers by their creation counter
+        sorted_managers = sorted(self.managers, key=lambda v: v[1].creation_counter)
+        for mgr_name, manager in sorted_managers:
+            as_manager, manager_path, qs_path, args, kwargs = manager.deconstruct()
+            if as_manager:
+                qs_class = import_string(qs_path)
+                yield mgr_name, qs_class.as_manager()
+            else:
+                manager_class = import_string(manager_path)
+                yield mgr_name, manager_class(*args, **kwargs)
+
+    def clone(self):
+        """Return an exact copy of this ModelState."""
+        return self.__class__(
+            app_label=self.app_label,
+            name=self.name,
+            fields=list(self.fields),
+            # Since options are shallow-copied here, operations such as
+            # AddIndex must replace their option (e.g 'indexes') rather
+            # than mutating it.
+            options=dict(self.options),
+            bases=self.bases,
+            managers=list(self.managers),
+        )
+
+    def render(self, apps):
+        """Create a Model object from our current state into the given apps."""
+        # First, make a Meta object
+        meta_contents = {'app_label': self.app_label, 'apps': apps, **self.options}
+        meta = type("Meta", (), meta_contents)
+        # Then, work out our bases
+        try:
+            bases = tuple(
+                (apps.get_model(base) if isinstance(base, str) else base)
+                for base in self.bases
+            )
+        except LookupError:
+            raise InvalidBasesError("Cannot resolve one or more bases from %r" % (self.bases,))
+        # Turn fields into a dict for the body, add other bits
+        body = {name: field.clone() for name, field in self.fields}
+        body['Meta'] = meta
+        body['__module__'] = "__fake__"
+
+        # Restore managers
+        body.update(self.construct_managers())
+        # Then, make a Model object (apps.register_model is called in __new__)
+        return type(self.name, bases, body)
+
+    def get_field_by_name(self, name):
+        for fname, field in self.fields:
+            if fname == name:
+                return field
+        raise ValueError("No field called %s on model %s" % (name, self.name))
+
+    def get_index_by_name(self, name):
+        for index in self.options['indexes']:
+            if index.name == name:
+                return index
+        raise ValueError("No index named %s on model %s" % (name, self.name))
+
+    def get_constraint_by_name(self, name):
+        for constraint in self.options['constraints']:
+            if constraint.name == name:
+                return constraint
+        raise ValueError('No constraint named %s on model %s' % (name, self.name))
+
+    def __repr__(self):
+        return "<%s: '%s.%s'>" % (self.__class__.__name__, self.app_label, self.name)
+
+    def __eq__(self, other):
+        return (
+            (self.app_label == other.app_label) and
+            (self.name == other.name) and
+            (len(self.fields) == len(other.fields)) and
+            all((k1 == k2 and (f1.deconstruct()[1:] == f2.deconstruct()[1:]))
+                for (k1, f1), (k2, f2) in zip(self.fields, other.fields)) and
+            (self.options == other.options) and
+            (self.bases == other.bases) and
+            (self.managers == other.managers)
+        )

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

@@ -0,0 +1,17 @@
+import datetime
+import re
+
+COMPILED_REGEX_TYPE = type(re.compile(''))
+
+
+class RegexObject:
+    def __init__(self, obj):
+        self.pattern = obj.pattern
+        self.flags = obj.flags
+
+    def __eq__(self, other):
+        return self.pattern == other.pattern and self.flags == other.flags
+
+
+def get_migration_name_timestamp():
+    return datetime.datetime.now().strftime("%Y%m%d_%H%M")

venv/lib/python3.7/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.7/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', 'r') 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(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 "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.7/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.7/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.7/site-packages/django/db/models/functions/text.py

@@ -0,0 +1,267 @@
+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
+
+
+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 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 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 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.7/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.7/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
+        )