17.12
This commit is contained in:
Mai Gillmann
@@ -0,0 +1,2 @@
|
||||
from .migration import Migration, swappable_dependency # NOQA
|
||||
from .operations import * # NOQA
|
||||
File diff suppressed because it is too large
Load Diff
@@ -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
|
||||
@@ -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
|
||||
@@ -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)
|
||||
@@ -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()
|
||||
@@ -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)
|
||||
)
|
||||
@@ -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")
|
||||
Reference in New Issue
Block a user