Debian Codegraph @

django/db/migrations/state.py

raw
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 )