| 1 |
import copy |
| 2 |
from collections import defaultdict |
| 3 |
from contextlib import contextmanager |
| 4 |
from functools import partial |
| 5 |
|
| 6 |
from django.apps import AppConfig |
| 7 |
from django.apps.registry import Apps |
| 8 |
from django.apps.registry import apps as global_apps |
| 9 |
from django.conf import settings |
| 10 |
from django.core.exceptions import FieldDoesNotExist |
| 11 |
from django.db import models |
| 12 |
from django.db.migrations.utils import field_is_referenced, get_references |
| 13 |
from django.db.models import NOT_PROVIDED |
| 14 |
from django.db.models.fields.related import RECURSIVE_RELATIONSHIP_CONSTANT |
| 15 |
from django.db.models.options import DEFAULT_NAMES, normalize_together |
| 16 |
from django.db.models.utils import make_model_tuple |
| 17 |
from django.utils.functional import cached_property |
| 18 |
from django.utils.module_loading import import_string |
| 19 |
from django.utils.version import get_docs_version |
| 20 |
|
| 21 |
from .exceptions import InvalidBasesError |
| 22 |
from .utils import resolve_relation |
| 23 |
|
| 24 |
|
| 25 |
def _get_app_label_and_model_name(model, app_label=""): |
| 26 |
if isinstance(model, str): |
| 27 |
split = model.split(".", 1) |
| 28 |
return tuple(split) if len(split) == 2 else (app_label, split[0]) |
| 29 |
else: |
| 30 |
return model._meta.app_label, model._meta.model_name |
| 31 |
|
| 32 |
|
| 33 |
def _get_related_models(m): |
| 34 |
"""Return all models that have a direct relationship to the given model.""" |
| 35 |
related_models = [ |
| 36 |
subclass |
| 37 |
for subclass in m.__subclasses__() |
| 38 |
if issubclass(subclass, models.Model) |
| 39 |
] |
| 40 |
related_fields_models = set() |
| 41 |
for f in m._meta.get_fields(include_parents=True, include_hidden=True): |
| 42 |
if ( |
| 43 |
f.is_relation |
| 44 |
and f.related_model is not None |
| 45 |
and not isinstance(f.related_model, str) |
| 46 |
): |
| 47 |
related_fields_models.add(f.model) |
| 48 |
related_models.append(f.related_model) |
| 49 |
# Reverse accessors of foreign keys to proxy models are attached to their |
| 50 |
# concrete proxied model. |
| 51 |
opts = m._meta |
| 52 |
if opts.proxy and m in related_fields_models: |
| 53 |
related_models.append(opts.concrete_model) |
| 54 |
return related_models |
| 55 |
|
| 56 |
|
| 57 |
def get_related_models_tuples(model): |
| 58 |
""" |
| 59 |
Return a list of typical (app_label, model_name) tuples for all related |
| 60 |
models for the given model. |
| 61 |
""" |
| 62 |
return { |
| 63 |
(rel_mod._meta.app_label, rel_mod._meta.model_name) |
| 64 |
for rel_mod in _get_related_models(model) |
| 65 |
} |
| 66 |
|
| 67 |
|
| 68 |
def get_related_models_recursive(model): |
| 69 |
""" |
| 70 |
Return all models that have a direct or indirect relationship |
| 71 |
to the given model. |
| 72 |
|
| 73 |
Relationships are either defined by explicit relational fields, like |
| 74 |
ForeignKey, ManyToManyField or OneToOneField, or by inheriting from another |
| 75 |
model (a superclass is related to its subclasses, but not vice versa). Note, |
| 76 |
however, that a model inheriting from a concrete model is also related to |
| 77 |
its superclass through the implicit *_ptr OneToOneField on the subclass. |
| 78 |
""" |
| 79 |
seen = set() |
| 80 |
queue = _get_related_models(model) |
| 81 |
for rel_mod in queue: |
| 82 |
rel_app_label, rel_model_name = ( |
| 83 |
rel_mod._meta.app_label, |
| 84 |
rel_mod._meta.model_name, |
| 85 |
) |
| 86 |
if (rel_app_label, rel_model_name) in seen: |
| 87 |
continue |
| 88 |
seen.add((rel_app_label, rel_model_name)) |
| 89 |
queue.extend(_get_related_models(rel_mod)) |
| 90 |
return seen - {(model._meta.app_label, model._meta.model_name)} |
| 91 |
|
| 92 |
|
| 93 |
class ProjectState: |
| 94 |
""" |
| 95 |
Represent the entire project's overall state. This is the item that is |
| 96 |
passed around - do it here rather than at the app level so that cross-app |
| 97 |
FKs/etc. resolve properly. |
| 98 |
""" |
| 99 |
|
| 100 |
def __init__(self, models=None, real_apps=None): |
| 101 |
self.models = models or {} |
| 102 |
# Apps to include from main registry, usually unmigrated ones |
| 103 |
if real_apps is None: |
| 104 |
real_apps = set() |
| 105 |
else: |
| 106 |
assert isinstance(real_apps, set) |
| 107 |
self.real_apps = real_apps |
| 108 |
self.is_delayed = False |
| 109 |
# {remote_model_key: {model_key: {field_name: field}}} |
| 110 |
self._relations = None |
| 111 |
|
| 112 |
@property |
| 113 |
def relations(self): |
| 114 |
if self._relations is None: |
| 115 |
self.resolve_fields_and_relations() |
| 116 |
return self._relations |
| 117 |
|
| 118 |
def add_model(self, model_state): |
| 119 |
model_key = model_state.app_label, model_state.name_lower |
| 120 |
self.models[model_key] = model_state |
| 121 |
if self._relations is not None: |
| 122 |
self.resolve_model_relations(model_key) |
| 123 |
if "apps" in self.__dict__: # hasattr would cache the property |
| 124 |
self.reload_model(*model_key) |
| 125 |
|
| 126 |
def remove_model(self, app_label, model_name): |
| 127 |
model_key = app_label, model_name |
| 128 |
del self.models[model_key] |
| 129 |
if self._relations is not None: |
| 130 |
self._relations.pop(model_key, None) |
| 131 |
# Call list() since _relations can change size during iteration. |
| 132 |
for related_model_key, model_relations in list(self._relations.items()): |
| 133 |
model_relations.pop(model_key, None) |
| 134 |
if not model_relations: |
| 135 |
del self._relations[related_model_key] |
| 136 |
if "apps" in self.__dict__: # hasattr would cache the property |
| 137 |
self.apps.unregister_model(*model_key) |
| 138 |
# Need to do this explicitly since unregister_model() doesn't clear |
| 139 |
# the cache automatically (#24513) |
| 140 |
self.apps.clear_cache() |
| 141 |
|
| 142 |
def rename_model(self, app_label, old_name, new_name): |
| 143 |
# Add a new model. |
| 144 |
old_name_lower = old_name.lower() |
| 145 |
new_name_lower = new_name.lower() |
| 146 |
renamed_model = self.models[app_label, old_name_lower].clone() |
| 147 |
renamed_model.name = new_name |
| 148 |
self.models[app_label, new_name_lower] = renamed_model |
| 149 |
# Repoint all fields pointing to the old model to the new one. |
| 150 |
old_model_tuple = (app_label, old_name_lower) |
| 151 |
new_remote_model = f"{app_label}.{new_name}" |
| 152 |
to_reload = set() |
| 153 |
for model_state, name, field, reference in get_references( |
| 154 |
self, old_model_tuple |
| 155 |
): |
| 156 |
changed_field = None |
| 157 |
if reference.to: |
| 158 |
changed_field = field.clone() |
| 159 |
changed_field.remote_field.model = new_remote_model |
| 160 |
if reference.through: |
| 161 |
if changed_field is None: |
| 162 |
changed_field = field.clone() |
| 163 |
changed_field.remote_field.through = new_remote_model |
| 164 |
if changed_field: |
| 165 |
model_state.fields[name] = changed_field |
| 166 |
to_reload.add((model_state.app_label, model_state.name_lower)) |
| 167 |
if self._relations is not None: |
| 168 |
old_name_key = app_label, old_name_lower |
| 169 |
new_name_key = app_label, new_name_lower |
| 170 |
if old_name_key in self._relations: |
| 171 |
self._relations[new_name_key] = self._relations.pop(old_name_key) |
| 172 |
for model_relations in self._relations.values(): |
| 173 |
if old_name_key in model_relations: |
| 174 |
model_relations[new_name_key] = model_relations.pop(old_name_key) |
| 175 |
# Reload models related to old model before removing the old model. |
| 176 |
self.reload_models(to_reload, delay=True) |
| 177 |
# Remove the old model. |
| 178 |
self.remove_model(app_label, old_name_lower) |
| 179 |
self.reload_model(app_label, new_name_lower, delay=True) |
| 180 |
|
| 181 |
def alter_model_options(self, app_label, model_name, options, option_keys=None): |
| 182 |
model_state = self.models[app_label, model_name] |
| 183 |
model_state.options = {**model_state.options, **options} |
| 184 |
if option_keys: |
| 185 |
for key in option_keys: |
| 186 |
if key not in options: |
| 187 |
model_state.options.pop(key, False) |
| 188 |
self.reload_model(app_label, model_name, delay=True) |
| 189 |
|
| 190 |
def remove_model_options(self, app_label, model_name, option_name, value_to_remove): |
| 191 |
model_state = self.models[app_label, model_name] |
| 192 |
if objs := model_state.options.get(option_name): |
| 193 |
model_state.options[option_name] = [ |
| 194 |
obj for obj in objs if tuple(obj) != tuple(value_to_remove) |
| 195 |
] |
| 196 |
self.reload_model(app_label, model_name, delay=True) |
| 197 |
|
| 198 |
def alter_model_managers(self, app_label, model_name, managers): |
| 199 |
model_state = self.models[app_label, model_name] |
| 200 |
model_state.managers = list(managers) |
| 201 |
self.reload_model(app_label, model_name, delay=True) |
| 202 |
|
| 203 |
def _append_option(self, app_label, model_name, option_name, obj): |
| 204 |
model_state = self.models[app_label, model_name] |
| 205 |
model_state.options[option_name] = [*model_state.options[option_name], obj] |
| 206 |
self.reload_model(app_label, model_name, delay=True) |
| 207 |
|
| 208 |
def _remove_option(self, app_label, model_name, option_name, obj_name): |
| 209 |
model_state = self.models[app_label, model_name] |
| 210 |
objs = model_state.options[option_name] |
| 211 |
model_state.options[option_name] = [obj for obj in objs if obj.name != obj_name] |
| 212 |
self.reload_model(app_label, model_name, delay=True) |
| 213 |
|
| 214 |
def _alter_option(self, app_label, model_name, option_name, obj_name, alt_obj): |
| 215 |
model_state = self.models[app_label, model_name] |
| 216 |
objs = model_state.options[option_name] |
| 217 |
model_state.options[option_name] = [ |
| 218 |
obj if obj.name != obj_name else alt_obj for obj in objs |
| 219 |
] |
| 220 |
self.reload_model(app_label, model_name, delay=True) |
| 221 |
|
| 222 |
def add_index(self, app_label, model_name, index): |
| 223 |
self._append_option(app_label, model_name, "indexes", index) |
| 224 |
|
| 225 |
def remove_index(self, app_label, model_name, index_name): |
| 226 |
self._remove_option(app_label, model_name, "indexes", index_name) |
| 227 |
|
| 228 |
def rename_index(self, app_label, model_name, old_index_name, new_index_name): |
| 229 |
model_state = self.models[app_label, model_name] |
| 230 |
objs = model_state.options["indexes"] |
| 231 |
|
| 232 |
new_indexes = [] |
| 233 |
for obj in objs: |
| 234 |
if obj.name == old_index_name: |
| 235 |
obj = obj.clone() |
| 236 |
obj.name = new_index_name |
| 237 |
new_indexes.append(obj) |
| 238 |
|
| 239 |
model_state.options["indexes"] = new_indexes |
| 240 |
self.reload_model(app_label, model_name, delay=True) |
| 241 |
|
| 242 |
def add_constraint(self, app_label, model_name, constraint): |
| 243 |
self._append_option(app_label, model_name, "constraints", constraint) |
| 244 |
|
| 245 |
def remove_constraint(self, app_label, model_name, constraint_name): |
| 246 |
self._remove_option(app_label, model_name, "constraints", constraint_name) |
| 247 |
|
| 248 |
def alter_constraint(self, app_label, model_name, constraint_name, constraint): |
| 249 |
self._alter_option( |
| 250 |
app_label, model_name, "constraints", constraint_name, constraint |
| 251 |
) |
| 252 |
|
| 253 |
def add_field(self, app_label, model_name, name, field, preserve_default): |
| 254 |
# If preserve default is off, don't use the default for future state. |
| 255 |
if not preserve_default: |
| 256 |
field = field.clone() |
| 257 |
field.default = NOT_PROVIDED |
| 258 |
else: |
| 259 |
field = field |
| 260 |
model_key = app_label, model_name |
| 261 |
self.models[model_key].fields[name] = field |
| 262 |
if self._relations is not None: |
| 263 |
self.resolve_model_field_relations(model_key, name, field) |
| 264 |
# Delay rendering of relationships if it's not a relational field. |
| 265 |
delay = not field.is_relation |
| 266 |
self.reload_model(*model_key, delay=delay) |
| 267 |
|
| 268 |
def remove_field(self, app_label, model_name, name): |
| 269 |
model_key = app_label, model_name |
| 270 |
model_state = self.models[model_key] |
| 271 |
old_field = model_state.fields.pop(name) |
| 272 |
if self._relations is not None: |
| 273 |
self.resolve_model_field_relations(model_key, name, old_field) |
| 274 |
# Delay rendering of relationships if it's not a relational field. |
| 275 |
delay = not old_field.is_relation |
| 276 |
self.reload_model(*model_key, delay=delay) |
| 277 |
|
| 278 |
def alter_field(self, app_label, model_name, name, field, preserve_default): |
| 279 |
if not preserve_default: |
| 280 |
field = field.clone() |
| 281 |
field.default = NOT_PROVIDED |
| 282 |
else: |
| 283 |
field = field |
| 284 |
model_key = app_label, model_name |
| 285 |
fields = self.models[model_key].fields |
| 286 |
if self._relations is not None: |
| 287 |
old_field = fields.pop(name) |
| 288 |
if old_field.is_relation: |
| 289 |
self.resolve_model_field_relations(model_key, name, old_field) |
| 290 |
fields[name] = field |
| 291 |
if field.is_relation: |
| 292 |
self.resolve_model_field_relations(model_key, name, field) |
| 293 |
else: |
| 294 |
fields[name] = field |
| 295 |
# TODO: investigate if old relational fields must be reloaded or if |
| 296 |
# it's sufficient if the new field is (#27737). |
| 297 |
# Delay rendering of relationships if it's not a relational field and |
| 298 |
# not referenced by a foreign key. |
| 299 |
delay = not field.is_relation and not field_is_referenced( |
| 300 |
self, model_key, (name, field) |
| 301 |
) |
| 302 |
self.reload_model(*model_key, delay=delay) |
| 303 |
|
| 304 |
def rename_field(self, app_label, model_name, old_name, new_name): |
| 305 |
model_key = app_label, model_name |
| 306 |
model_state = self.models[model_key] |
| 307 |
# Rename the field. |
| 308 |
fields = model_state.fields |
| 309 |
try: |
| 310 |
found = fields.pop(old_name) |
| 311 |
except KeyError: |
| 312 |
raise FieldDoesNotExist( |
| 313 |
f"{app_label}.{model_name} has no field named '{old_name}'" |
| 314 |
) |
| 315 |
fields[new_name] = found |
| 316 |
for field in fields.values(): |
| 317 |
# Fix from_fields to refer to the new field. |
| 318 |
from_fields = getattr(field, "from_fields", None) |
| 319 |
if from_fields: |
| 320 |
field.from_fields = tuple( |
| 321 |
[ |
| 322 |
new_name if from_field_name == old_name else from_field_name |
| 323 |
for from_field_name in from_fields |
| 324 |
] |
| 325 |
) |
| 326 |
# Fix field names (e.g. for CompositePrimaryKey) to refer to the |
| 327 |
# new field. |
| 328 |
if field_names := getattr(field, "field_names", None): |
| 329 |
if old_name in field_names: |
| 330 |
field.field_names = tuple( |
| 331 |
[ |
| 332 |
new_name if field_name == old_name else field_name |
| 333 |
for field_name in field.field_names |
| 334 |
] |
| 335 |
) |
| 336 |
# Fix index/unique_together to refer to the new field. |
| 337 |
options = model_state.options |
| 338 |
for option in ("index_together", "unique_together"): |
| 339 |
if option in options: |
| 340 |
options[option] = [ |
| 341 |
[new_name if n == old_name else n for n in together] |
| 342 |
for together in options[option] |
| 343 |
] |
| 344 |
# Fix to_fields to refer to the new field. |
| 345 |
delay = True |
| 346 |
references = get_references(self, model_key, (old_name, found)) |
| 347 |
for *_, field, reference in references: |
| 348 |
delay = False |
| 349 |
if reference.to: |
| 350 |
remote_field, to_fields = reference.to |
| 351 |
if getattr(remote_field, "field_name", None) == old_name: |
| 352 |
remote_field.field_name = new_name |
| 353 |
if to_fields: |
| 354 |
field.to_fields = tuple( |
| 355 |
[ |
| 356 |
new_name if to_field_name == old_name else to_field_name |
| 357 |
for to_field_name in to_fields |
| 358 |
] |
| 359 |
) |
| 360 |
if self._relations is not None: |
| 361 |
old_name_lower = old_name.lower() |
| 362 |
new_name_lower = new_name.lower() |
| 363 |
for to_model in self._relations.values(): |
| 364 |
if old_name_lower in to_model[model_key]: |
| 365 |
field = to_model[model_key].pop(old_name_lower) |
| 366 |
field.name = new_name_lower |
| 367 |
to_model[model_key][new_name_lower] = field |
| 368 |
self.reload_model(*model_key, delay=delay) |
| 369 |
|
| 370 |
def _find_reload_model(self, app_label, model_name, delay=False): |
| 371 |
if delay: |
| 372 |
self.is_delayed = True |
| 373 |
|
| 374 |
related_models = set() |
| 375 |
|
| 376 |
try: |
| 377 |
old_model = self.apps.get_model(app_label, model_name) |
| 378 |
except LookupError: |
| 379 |
pass |
| 380 |
else: |
| 381 |
# Get all relations to and from the old model before reloading, |
| 382 |
# as _meta.apps may change |
| 383 |
if delay: |
| 384 |
related_models = get_related_models_tuples(old_model) |
| 385 |
else: |
| 386 |
related_models = get_related_models_recursive(old_model) |
| 387 |
|
| 388 |
# Get all outgoing references from the model to be rendered |
| 389 |
model_state = self.models[(app_label, model_name)] |
| 390 |
# Directly related models are the models pointed to by ForeignKeys, |
| 391 |
# OneToOneFields, and ManyToManyFields. |
| 392 |
direct_related_models = set() |
| 393 |
for field in model_state.fields.values(): |
| 394 |
if field.is_relation: |
| 395 |
if field.remote_field.model == RECURSIVE_RELATIONSHIP_CONSTANT: |
| 396 |
continue |
| 397 |
rel_app_label, rel_model_name = _get_app_label_and_model_name( |
| 398 |
field.related_model, app_label |
| 399 |
) |
| 400 |
direct_related_models.add((rel_app_label, rel_model_name.lower())) |
| 401 |
|
| 402 |
# For all direct related models recursively get all related models. |
| 403 |
related_models.update(direct_related_models) |
| 404 |
for rel_app_label, rel_model_name in direct_related_models: |
| 405 |
try: |
| 406 |
rel_model = self.apps.get_model(rel_app_label, rel_model_name) |
| 407 |
except LookupError: |
| 408 |
pass |
| 409 |
else: |
| 410 |
if delay: |
| 411 |
related_models.update(get_related_models_tuples(rel_model)) |
| 412 |
else: |
| 413 |
related_models.update(get_related_models_recursive(rel_model)) |
| 414 |
|
| 415 |
# Include the model itself |
| 416 |
related_models.add((app_label, model_name)) |
| 417 |
|
| 418 |
return related_models |
| 419 |
|
| 420 |
def reload_model(self, app_label, model_name, delay=False): |
| 421 |
if "apps" in self.__dict__: # hasattr would cache the property |
| 422 |
related_models = self._find_reload_model(app_label, model_name, delay) |
| 423 |
self._reload(related_models) |
| 424 |
|
| 425 |
def reload_models(self, models, delay=True): |
| 426 |
if "apps" in self.__dict__: # hasattr would cache the property |
| 427 |
related_models = set() |
| 428 |
for app_label, model_name in models: |
| 429 |
related_models.update( |
| 430 |
self._find_reload_model(app_label, model_name, delay) |
| 431 |
) |
| 432 |
self._reload(related_models) |
| 433 |
|
| 434 |
def _reload(self, related_models): |
| 435 |
# Unregister all related models |
| 436 |
with self.apps.bulk_update(): |
| 437 |
for rel_app_label, rel_model_name in related_models: |
| 438 |
self.apps.unregister_model(rel_app_label, rel_model_name) |
| 439 |
|
| 440 |
states_to_be_rendered = [] |
| 441 |
# Gather all models states of those models that will be rerendered. |
| 442 |
# This includes: |
| 443 |
# 1. All related models of unmigrated apps |
| 444 |
for model_state in self.apps.real_models: |
| 445 |
if (model_state.app_label, model_state.name_lower) in related_models: |
| 446 |
states_to_be_rendered.append(model_state) |
| 447 |
|
| 448 |
# 2. All related models of migrated apps |
| 449 |
for rel_app_label, rel_model_name in related_models: |
| 450 |
try: |
| 451 |
model_state = self.models[rel_app_label, rel_model_name] |
| 452 |
except KeyError: |
| 453 |
pass |
| 454 |
else: |
| 455 |
states_to_be_rendered.append(model_state) |
| 456 |
|
| 457 |
# Render all models |
| 458 |
self.apps.render_multiple(states_to_be_rendered) |
| 459 |
|
| 460 |
def update_model_field_relation( |
| 461 |
self, |
| 462 |
model, |
| 463 |
model_key, |
| 464 |
field_name, |
| 465 |
field, |
| 466 |
concretes, |
| 467 |
): |
| 468 |
remote_model_key = resolve_relation(model, *model_key) |
| 469 |
if remote_model_key[0] not in self.real_apps and remote_model_key in concretes: |
| 470 |
remote_model_key = concretes[remote_model_key] |
| 471 |
relations_to_remote_model = self._relations[remote_model_key] |
| 472 |
if field_name in self.models[model_key].fields: |
| 473 |
# The assert holds because it's a new relation, or an altered |
| 474 |
# relation, in which case references have been removed by |
| 475 |
# alter_field(). |
| 476 |
assert field_name not in relations_to_remote_model[model_key] |
| 477 |
relations_to_remote_model[model_key][field_name] = field |
| 478 |
else: |
| 479 |
del relations_to_remote_model[model_key][field_name] |
| 480 |
if not relations_to_remote_model[model_key]: |
| 481 |
del relations_to_remote_model[model_key] |
| 482 |
|
| 483 |
def resolve_model_field_relations( |
| 484 |
self, |
| 485 |
model_key, |
| 486 |
field_name, |
| 487 |
field, |
| 488 |
concretes=None, |
| 489 |
): |
| 490 |
remote_field = field.remote_field |
| 491 |
if not remote_field: |
| 492 |
return |
| 493 |
if concretes is None: |
| 494 |
concretes, _ = self._get_concrete_models_mapping_and_proxy_models() |
| 495 |
|
| 496 |
self.update_model_field_relation( |
| 497 |
remote_field.model, |
| 498 |
model_key, |
| 499 |
field_name, |
| 500 |
field, |
| 501 |
concretes, |
| 502 |
) |
| 503 |
|
| 504 |
through = getattr(remote_field, "through", None) |
| 505 |
if not through: |
| 506 |
return |
| 507 |
self.update_model_field_relation( |
| 508 |
through, model_key, field_name, field, concretes |
| 509 |
) |
| 510 |
|
| 511 |
def resolve_model_relations(self, model_key, concretes=None): |
| 512 |
if concretes is None: |
| 513 |
concretes, _ = self._get_concrete_models_mapping_and_proxy_models() |
| 514 |
|
| 515 |
model_state = self.models[model_key] |
| 516 |
for field_name, field in model_state.fields.items(): |
| 517 |
self.resolve_model_field_relations(model_key, field_name, field, concretes) |
| 518 |
|
| 519 |
def resolve_fields_and_relations(self): |
| 520 |
# Resolve fields. |
| 521 |
for model_state in self.models.values(): |
| 522 |
for field_name, field in model_state.fields.items(): |
| 523 |
field.name = field_name |
| 524 |
# Resolve relations. |
| 525 |
# {remote_model_key: {model_key: {field_name: field}}} |
| 526 |
self._relations = defaultdict(partial(defaultdict, dict)) |
| 527 |
concretes, proxies = self._get_concrete_models_mapping_and_proxy_models() |
| 528 |
|
| 529 |
for model_key in concretes: |
| 530 |
self.resolve_model_relations(model_key, concretes) |
| 531 |
|
| 532 |
for model_key in proxies: |
| 533 |
self._relations[model_key] = self._relations[concretes[model_key]] |
| 534 |
|
| 535 |
def get_concrete_model_key(self, model): |
| 536 |
( |
| 537 |
concrete_models_mapping, |
| 538 |
_, |
| 539 |
) = self._get_concrete_models_mapping_and_proxy_models() |
| 540 |
model_key = make_model_tuple(model) |
| 541 |
return concrete_models_mapping[model_key] |
| 542 |
|
| 543 |
def _get_concrete_models_mapping_and_proxy_models(self): |
| 544 |
concrete_models_mapping = {} |
| 545 |
proxy_models = {} |
| 546 |
# Split models to proxy and concrete models. |
| 547 |
for model_key, model_state in self.models.items(): |
| 548 |
if model_state.options.get("proxy"): |
| 549 |
proxy_models[model_key] = model_state |
| 550 |
# Find a concrete model for the proxy. |
| 551 |
concrete_models_mapping[model_key] = ( |
| 552 |
self._find_concrete_model_from_proxy( |
| 553 |
proxy_models, |
| 554 |
model_state, |
| 555 |
) |
| 556 |
) |
| 557 |
else: |
| 558 |
concrete_models_mapping[model_key] = model_key |
| 559 |
return concrete_models_mapping, proxy_models |
| 560 |
|
| 561 |
def _find_concrete_model_from_proxy(self, proxy_models, model_state): |
| 562 |
for base in model_state.bases: |
| 563 |
if not (isinstance(base, str) or issubclass(base, models.Model)): |
| 564 |
continue |
| 565 |
base_key = make_model_tuple(base) |
| 566 |
base_state = proxy_models.get(base_key) |
| 567 |
if not base_state: |
| 568 |
# Concrete model found, stop looking at bases. |
| 569 |
return base_key |
| 570 |
return self._find_concrete_model_from_proxy(proxy_models, base_state) |
| 571 |
|
| 572 |
def clone(self): |
| 573 |
"""Return an exact copy of this ProjectState.""" |
| 574 |
new_state = ProjectState( |
| 575 |
models={k: v.clone() for k, v in self.models.items()}, |
| 576 |
real_apps=self.real_apps, |
| 577 |
) |
| 578 |
if "apps" in self.__dict__: |
| 579 |
new_state.apps = self.apps.clone() |
| 580 |
new_state.is_delayed = self.is_delayed |
| 581 |
return new_state |
| 582 |
|
| 583 |
def clear_delayed_apps_cache(self): |
| 584 |
if self.is_delayed and "apps" in self.__dict__: |
| 585 |
del self.__dict__["apps"] |
| 586 |
|
| 587 |
@cached_property |
| 588 |
def apps(self): |
| 589 |
return StateApps(self.real_apps, self.models) |
| 590 |
|
| 591 |
@classmethod |
| 592 |
def from_apps(cls, apps): |
| 593 |
"""Take an Apps and return a ProjectState matching it.""" |
| 594 |
app_models = {} |
| 595 |
for model in apps.get_models(include_swapped=True): |
| 596 |
model_state = ModelState.from_model(model) |
| 597 |
app_models[(model_state.app_label, model_state.name_lower)] = model_state |
| 598 |
return cls(app_models) |
| 599 |
|
| 600 |
def __eq__(self, other): |
| 601 |
return self.models == other.models and self.real_apps == other.real_apps |
| 602 |
|
| 603 |
|
| 604 |
class AppConfigStub(AppConfig): |
| 605 |
"""Stub of an AppConfig. Only provides a label and a dict of models.""" |
| 606 |
|
| 607 |
def __init__(self, label): |
| 608 |
self.apps = None |
| 609 |
self.models = {} |
| 610 |
# App-label and app-name are not the same thing, so technically passing |
| 611 |
# in the label here is wrong. In practice, migrations don't care about |
| 612 |
# the app name, but we need something unique, and the label works fine. |
| 613 |
self.label = label |
| 614 |
self.name = label |
| 615 |
|
| 616 |
def import_models(self): |
| 617 |
self.models = self.apps.all_models[self.label] |
| 618 |
|
| 619 |
|
| 620 |
class StateApps(Apps): |
| 621 |
""" |
| 622 |
Subclass of the global Apps registry class to better handle dynamic model |
| 623 |
additions and removals. |
| 624 |
""" |
| 625 |
|
| 626 |
def __init__(self, real_apps, models, ignore_swappable=False): |
| 627 |
# Any apps in self.real_apps should have all their models included |
| 628 |
# in the render. We don't use the original model instances as there |
| 629 |
# are some variables that refer to the Apps object. |
| 630 |
# FKs/M2Ms from real apps are also not included as they just |
| 631 |
# mess things up with partial states (due to lack of dependencies) |
| 632 |
self.real_models = [] |
| 633 |
for app_label in real_apps: |
| 634 |
app = global_apps.get_app_config(app_label) |
| 635 |
for model in app.get_models(): |
| 636 |
self.real_models.append(ModelState.from_model(model, exclude_rels=True)) |
| 637 |
# Populate the app registry with a stub for each application. |
| 638 |
app_labels = {model_state.app_label for model_state in models.values()} |
| 639 |
app_configs = [ |
| 640 |
AppConfigStub(label) for label in sorted([*real_apps, *app_labels]) |
| 641 |
] |
| 642 |
super().__init__(app_configs) |
| 643 |
|
| 644 |
# These locks get in the way of copying as implemented in clone(), |
| 645 |
# which is called whenever Django duplicates a StateApps before |
| 646 |
# updating it. |
| 647 |
self._lock = None |
| 648 |
self.ready_event = None |
| 649 |
|
| 650 |
self.render_multiple([*models.values(), *self.real_models]) |
| 651 |
|
| 652 |
# There shouldn't be any operations pending at this point. |
| 653 |
from django.core.checks.model_checks import _check_lazy_references |
| 654 |
|
| 655 |
ignore = ( |
| 656 |
{make_model_tuple(settings.AUTH_USER_MODEL)} if ignore_swappable else set() |
| 657 |
) |
| 658 |
errors = _check_lazy_references(self, ignore=ignore) |
| 659 |
if errors: |
| 660 |
raise ValueError("\n".join(error.msg for error in errors)) |
| 661 |
|
| 662 |
@contextmanager |
| 663 |
def bulk_update(self): |
| 664 |
# Avoid clearing each model's cache for each change. Instead, clear |
| 665 |
# all caches when we're finished updating the model instances. |
| 666 |
ready = self.ready |
| 667 |
self.ready = False |
| 668 |
try: |
| 669 |
yield |
| 670 |
finally: |
| 671 |
self.ready = ready |
| 672 |
self.clear_cache() |
| 673 |
|
| 674 |
def render_multiple(self, model_states): |
| 675 |
# We keep trying to render the models in a loop, ignoring invalid |
| 676 |
# base errors, until the size of the unrendered models doesn't |
| 677 |
# decrease by at least one, meaning there's a base dependency loop/ |
| 678 |
# missing base. |
| 679 |
if not model_states: |
| 680 |
return |
| 681 |
# Prevent that all model caches are expired for each render. |
| 682 |
with self.bulk_update(): |
| 683 |
unrendered_models = model_states |
| 684 |
while unrendered_models: |
| 685 |
new_unrendered_models = [] |
| 686 |
for model in unrendered_models: |
| 687 |
try: |
| 688 |
model.render(self) |
| 689 |
except InvalidBasesError: |
| 690 |
new_unrendered_models.append(model) |
| 691 |
if len(new_unrendered_models) == len(unrendered_models): |
| 692 |
raise InvalidBasesError( |
| 693 |
"Cannot resolve bases for %r\nThis can happen if you are " |
| 694 |
"inheriting models from an app with migrations (e.g. " |
| 695 |
"contrib.auth)\n in an app with no migrations; see " |
| 696 |
"https://docs.djangoproject.com/en/%s/topics/migrations/" |
| 697 |
"#dependencies for more" |
| 698 |
% (new_unrendered_models, get_docs_version()) |
| 699 |
) |
| 700 |
unrendered_models = new_unrendered_models |
| 701 |
|
| 702 |
def clone(self): |
| 703 |
"""Return a clone of this registry.""" |
| 704 |
clone = StateApps([], {}) |
| 705 |
clone.all_models = copy.deepcopy(self.all_models) |
| 706 |
|
| 707 |
for app_label in self.app_configs: |
| 708 |
app_config = AppConfigStub(app_label) |
| 709 |
app_config.apps = clone |
| 710 |
app_config.import_models() |
| 711 |
clone.app_configs[app_label] = app_config |
| 712 |
|
| 713 |
# No need to actually clone them, they'll never change |
| 714 |
clone.real_models = self.real_models |
| 715 |
return clone |
| 716 |
|
| 717 |
def register_model(self, app_label, model): |
| 718 |
self.all_models[app_label][model._meta.model_name] = model |
| 719 |
if app_label not in self.app_configs: |
| 720 |
self.app_configs[app_label] = AppConfigStub(app_label) |
| 721 |
self.app_configs[app_label].apps = self |
| 722 |
self.app_configs[app_label].models[model._meta.model_name] = model |
| 723 |
self.do_pending_operations(model) |
| 724 |
self.clear_cache() |
| 725 |
|
| 726 |
def unregister_model(self, app_label, model_name): |
| 727 |
try: |
| 728 |
del self.all_models[app_label][model_name] |
| 729 |
del self.app_configs[app_label].models[model_name] |
| 730 |
except KeyError: |
| 731 |
pass |
| 732 |
|
| 733 |
|
| 734 |
class ModelState: |
| 735 |
""" |
| 736 |
Represent a Django Model. Don't use the actual Model class as it's not |
| 737 |
designed to have its options changed - instead, mutate this one and then |
| 738 |
render it into a Model as required. |
| 739 |
|
| 740 |
Note that while you are allowed to mutate .fields, you are not allowed |
| 741 |
to mutate the Field instances inside there themselves - you must instead |
| 742 |
assign new ones, as these are not detached during a clone. |
| 743 |
""" |
| 744 |
|
| 745 |
def __init__( |
| 746 |
self, app_label, name, fields, options=None, bases=None, managers=None |
| 747 |
): |
| 748 |
self.app_label = app_label |
| 749 |
self.name = name |
| 750 |
self.fields = dict(fields) |
| 751 |
self.options = options or {} |
| 752 |
self.options.setdefault("indexes", []) |
| 753 |
self.options.setdefault("constraints", []) |
| 754 |
self.bases = bases or (models.Model,) |
| 755 |
self.managers = managers or [] |
| 756 |
for name, field in self.fields.items(): |
| 757 |
# Sanity-check that fields are NOT already bound to a model. |
| 758 |
if hasattr(field, "model"): |
| 759 |
raise ValueError( |
| 760 |
'ModelState.fields cannot be bound to a model - "%s" is.' % name |
| 761 |
) |
| 762 |
# Sanity-check that relation fields are NOT referring to a model class. |
| 763 |
if field.is_relation and hasattr(field.related_model, "_meta"): |
| 764 |
raise ValueError( |
| 765 |
'Model fields in "ModelState.fields" cannot refer to a model class ' |
| 766 |
f'- "{self.app_label}.{self.name}.{name}.to" does. Use a string ' |
| 767 |
"reference instead." |
| 768 |
) |
| 769 |
if field.many_to_many and hasattr(field.remote_field.through, "_meta"): |
| 770 |
raise ValueError( |
| 771 |
'Model fields in "ModelState.fields" cannot refer to a model class ' |
| 772 |
f'- "{self.app_label}.{self.name}.{name}.through" does. Use a ' |
| 773 |
"string reference instead." |
| 774 |
) |
| 775 |
# Sanity-check that indexes have their name set. |
| 776 |
for index in self.options["indexes"]: |
| 777 |
if not index.name: |
| 778 |
raise ValueError( |
| 779 |
"Indexes passed to ModelState require a name attribute. " |
| 780 |
"%r doesn't have one." % index |
| 781 |
) |
| 782 |
|
| 783 |
@cached_property |
| 784 |
def name_lower(self): |
| 785 |
return self.name.lower() |
| 786 |
|
| 787 |
def get_field(self, field_name): |
| 788 |
if ( |
| 789 |
field_name == "_order" |
| 790 |
and self.options.get("order_with_respect_to") is not None |
| 791 |
): |
| 792 |
field_name = self.options["order_with_respect_to"] |
| 793 |
return self.fields[field_name] |
| 794 |
|
| 795 |
@classmethod |
| 796 |
def from_model(cls, model, exclude_rels=False): |
| 797 |
"""Given a model, return a ModelState representing it.""" |
| 798 |
# Deconstruct the fields |
| 799 |
fields = [] |
| 800 |
for field in model._meta.local_fields: |
| 801 |
if getattr(field, "remote_field", None) and exclude_rels: |
| 802 |
continue |
| 803 |
if isinstance(field, models.OrderWrt): |
| 804 |
continue |
| 805 |
name = field.name |
| 806 |
try: |
| 807 |
fields.append((name, field.clone())) |
| 808 |
except TypeError as e: |
| 809 |
raise TypeError( |
| 810 |
"Couldn't reconstruct field %s on %s: %s" |
| 811 |
% ( |
| 812 |
name, |
| 813 |
model._meta.label, |
| 814 |
e, |
| 815 |
) |
| 816 |
) |
| 817 |
if not exclude_rels: |
| 818 |
for field in model._meta.local_many_to_many: |
| 819 |
name = field.name |
| 820 |
try: |
| 821 |
fields.append((name, field.clone())) |
| 822 |
except TypeError as e: |
| 823 |
raise TypeError( |
| 824 |
"Couldn't reconstruct m2m field %s on %s: %s" |
| 825 |
% ( |
| 826 |
name, |
| 827 |
model._meta.object_name, |
| 828 |
e, |
| 829 |
) |
| 830 |
) |
| 831 |
# Extract the options |
| 832 |
options = {} |
| 833 |
for name in DEFAULT_NAMES: |
| 834 |
# Ignore some special options |
| 835 |
if name in ["apps", "app_label"]: |
| 836 |
continue |
| 837 |
elif name in model._meta.original_attrs: |
| 838 |
if name == "unique_together": |
| 839 |
ut = model._meta.original_attrs["unique_together"] |
| 840 |
options[name] = set(normalize_together(ut)) |
| 841 |
elif name == "indexes": |
| 842 |
indexes = [idx.clone() for idx in model._meta.indexes] |
| 843 |
for index in indexes: |
| 844 |
if not index.name: |
| 845 |
index.set_name_with_model(model) |
| 846 |
options["indexes"] = indexes |
| 847 |
elif name == "constraints": |
| 848 |
options["constraints"] = [ |
| 849 |
con.clone() for con in model._meta.constraints |
| 850 |
] |
| 851 |
else: |
| 852 |
options[name] = model._meta.original_attrs[name] |
| 853 |
# If we're ignoring relationships, remove all field-listing model |
| 854 |
# options (that option basically just means "make a stub model") |
| 855 |
if exclude_rels: |
| 856 |
for key in ["unique_together", "order_with_respect_to"]: |
| 857 |
if key in options: |
| 858 |
del options[key] |
| 859 |
# Private fields are ignored, so remove options that refer to them. |
| 860 |
elif options.get("order_with_respect_to") in { |
| 861 |
field.name for field in model._meta.private_fields |
| 862 |
}: |
| 863 |
del options["order_with_respect_to"] |
| 864 |
|
| 865 |
def flatten_bases(model): |
| 866 |
bases = [] |
| 867 |
for base in model.__bases__: |
| 868 |
if hasattr(base, "_meta") and base._meta.abstract: |
| 869 |
bases.extend(flatten_bases(base)) |
| 870 |
else: |
| 871 |
bases.append(base) |
| 872 |
return bases |
| 873 |
|
| 874 |
# We can't rely on __mro__ directly because we only want to flatten |
| 875 |
# abstract models and not the whole tree. However by recursing on |
| 876 |
# __bases__ we may end up with duplicates and ordering issues, we |
| 877 |
# therefore discard any duplicates and reorder the bases according |
| 878 |
# to their index in the MRO. |
| 879 |
flattened_bases = sorted( |
| 880 |
set(flatten_bases(model)), key=lambda x: model.__mro__.index(x) |
| 881 |
) |
| 882 |
|
| 883 |
# Make our record |
| 884 |
bases = tuple( |
| 885 |
(base._meta.label_lower if hasattr(base, "_meta") else base) |
| 886 |
for base in flattened_bases |
| 887 |
) |
| 888 |
# Ensure at least one base inherits from models.Model |
| 889 |
if not any( |
| 890 |
(isinstance(base, str) or issubclass(base, models.Model)) for base in bases |
| 891 |
): |
| 892 |
bases = (models.Model,) |
| 893 |
|
| 894 |
managers = [] |
| 895 |
manager_names = set() |
| 896 |
default_manager_shim = None |
| 897 |
for manager in model._meta.managers: |
| 898 |
if manager.name in manager_names: |
| 899 |
# Skip overridden managers. |
| 900 |
continue |
| 901 |
elif manager.use_in_migrations: |
| 902 |
# Copy managers usable in migrations. |
| 903 |
new_manager = copy.copy(manager) |
| 904 |
new_manager._set_creation_counter() |
| 905 |
elif manager is model._base_manager or manager is model._default_manager: |
| 906 |
# Shim custom managers used as default and base managers. |
| 907 |
new_manager = models.Manager() |
| 908 |
new_manager.model = manager.model |
| 909 |
new_manager.name = manager.name |
| 910 |
if manager is model._default_manager: |
| 911 |
default_manager_shim = new_manager |
| 912 |
else: |
| 913 |
continue |
| 914 |
manager_names.add(manager.name) |
| 915 |
managers.append((manager.name, new_manager)) |
| 916 |
|
| 917 |
# Ignore a shimmed default manager called objects if it's the only one. |
| 918 |
if managers == [("objects", default_manager_shim)]: |
| 919 |
managers = [] |
| 920 |
|
| 921 |
# Construct the new ModelState |
| 922 |
return cls( |
| 923 |
model._meta.app_label, |
| 924 |
model._meta.object_name, |
| 925 |
fields, |
| 926 |
options, |
| 927 |
bases, |
| 928 |
managers, |
| 929 |
) |
| 930 |
|
| 931 |
def construct_managers(self): |
| 932 |
"""Deep-clone the managers using deconstruction.""" |
| 933 |
# Sort all managers by their creation counter |
| 934 |
sorted_managers = sorted(self.managers, key=lambda v: v[1].creation_counter) |
| 935 |
for mgr_name, manager in sorted_managers: |
| 936 |
as_manager, manager_path, qs_path, args, kwargs = manager.deconstruct() |
| 937 |
if as_manager: |
| 938 |
qs_class = import_string(qs_path) |
| 939 |
yield mgr_name, qs_class.as_manager() |
| 940 |
else: |
| 941 |
manager_class = import_string(manager_path) |
| 942 |
yield mgr_name, manager_class(*args, **kwargs) |
| 943 |
|
| 944 |
def clone(self): |
| 945 |
"""Return an exact copy of this ModelState.""" |
| 946 |
return self.__class__( |
| 947 |
app_label=self.app_label, |
| 948 |
name=self.name, |
| 949 |
fields=dict(self.fields), |
| 950 |
# Since options are shallow-copied here, operations such as |
| 951 |
# AddIndex must replace their option (e.g 'indexes') rather |
| 952 |
# than mutating it. |
| 953 |
options=dict(self.options), |
| 954 |
bases=self.bases, |
| 955 |
managers=list(self.managers), |
| 956 |
) |
| 957 |
|
| 958 |
def render(self, apps): |
| 959 |
"""Create a Model object from our current state into the given apps.""" |
| 960 |
# First, make a Meta object |
| 961 |
meta_options = {**self.options} |
| 962 |
# Prune index_together from options as it's no longer an allowed meta |
| 963 |
# attribute. |
| 964 |
meta_options.pop("index_together", None) |
| 965 |
meta_contents = {"app_label": self.app_label, "apps": apps, **meta_options} |
| 966 |
meta = type("Meta", (), meta_contents) |
| 967 |
# Then, work out our bases |
| 968 |
try: |
| 969 |
bases = tuple( |
| 970 |
(apps.get_model(base) if isinstance(base, str) else base) |
| 971 |
for base in self.bases |
| 972 |
) |
| 973 |
except LookupError: |
| 974 |
raise InvalidBasesError( |
| 975 |
"Cannot resolve one or more bases from %r" % (self.bases,) |
| 976 |
) |
| 977 |
# Clone fields for the body, add other bits. |
| 978 |
body = {name: field.clone() for name, field in self.fields.items()} |
| 979 |
body["Meta"] = meta |
| 980 |
body["__module__"] = "__fake__" |
| 981 |
|
| 982 |
# Restore managers |
| 983 |
body.update(self.construct_managers()) |
| 984 |
# Then, make a Model object (apps.register_model is called in __new__) |
| 985 |
return type(self.name, bases, body) |
| 986 |
|
| 987 |
def get_index_by_name(self, name): |
| 988 |
for index in self.options["indexes"]: |
| 989 |
if index.name == name: |
| 990 |
return index |
| 991 |
raise ValueError("No index named %s on model %s" % (name, self.name)) |
| 992 |
|
| 993 |
def get_constraint_by_name(self, name): |
| 994 |
for constraint in self.options["constraints"]: |
| 995 |
if constraint.name == name: |
| 996 |
return constraint |
| 997 |
raise ValueError("No constraint named %s on model %s" % (name, self.name)) |
| 998 |
|
| 999 |
def __repr__(self): |
| 1000 |
return "<%s: '%s.%s'>" % (self.__class__.__name__, self.app_label, self.name) |
| 1001 |
|
| 1002 |
def __eq__(self, other): |
| 1003 |
return ( |
| 1004 |
(self.app_label == other.app_label) |
| 1005 |
and (self.name == other.name) |
| 1006 |
and (len(self.fields) == len(other.fields)) |
| 1007 |
and all( |
| 1008 |
k1 == k2 and f1.deconstruct()[1:] == f2.deconstruct()[1:] |
| 1009 |
for (k1, f1), (k2, f2) in zip( |
| 1010 |
sorted(self.fields.items()), |
| 1011 |
sorted(other.fields.items()), |
| 1012 |
) |
| 1013 |
) |
| 1014 |
and (self.options == other.options) |
| 1015 |
and (self.bases == other.bases) |
| 1016 |
and (self.managers == other.managers) |
| 1017 |
) |