OLD | NEW |
(Empty) | |
| 1 from __future__ import unicode_literals |
| 2 |
| 3 import copy |
| 4 import warnings |
| 5 from collections import OrderedDict |
| 6 from contextlib import contextmanager |
| 7 |
| 8 from django.apps import AppConfig |
| 9 from django.apps.registry import Apps, apps as global_apps |
| 10 from django.conf import settings |
| 11 from django.db import models |
| 12 from django.db.models.fields.proxy import OrderWrt |
| 13 from django.db.models.fields.related import RECURSIVE_RELATIONSHIP_CONSTANT |
| 14 from django.db.models.options import DEFAULT_NAMES, normalize_together |
| 15 from django.db.models.utils import make_model_tuple |
| 16 from django.utils import six |
| 17 from django.utils.deprecation import RemovedInDjango20Warning |
| 18 from django.utils.encoding import force_text |
| 19 from django.utils.functional import cached_property |
| 20 from django.utils.module_loading import import_string |
| 21 from django.utils.version import get_docs_version |
| 22 |
| 23 from .exceptions import InvalidBasesError |
| 24 |
| 25 |
| 26 def _get_app_label_and_model_name(model, app_label=''): |
| 27 if isinstance(model, six.string_types): |
| 28 split = model.split('.', 1) |
| 29 return (tuple(split) if len(split) == 2 else (app_label, split[0])) |
| 30 else: |
| 31 return model._meta.app_label, model._meta.model_name |
| 32 |
| 33 |
| 34 def _get_related_models(m): |
| 35 """ |
| 36 Return all models that have a direct relationship to the given model. |
| 37 """ |
| 38 related_models = [ |
| 39 subclass for subclass in m.__subclasses__() |
| 40 if issubclass(subclass, models.Model) |
| 41 ] |
| 42 related_fields_models = set() |
| 43 for f in m._meta.get_fields(include_parents=True, include_hidden=True): |
| 44 if f.is_relation and f.related_model is not None and not isinstance(f.re
lated_model, six.string_types): |
| 45 related_fields_models.add(f.model) |
| 46 related_models.append(f.related_model) |
| 47 # Reverse accessors of foreign keys to proxy models are attached to their |
| 48 # concrete proxied model. |
| 49 opts = m._meta |
| 50 if opts.proxy and m in related_fields_models: |
| 51 related_models.append(opts.concrete_model) |
| 52 return related_models |
| 53 |
| 54 |
| 55 def get_related_models_tuples(model): |
| 56 """ |
| 57 Return a list of typical (app_label, model_name) tuples for all related |
| 58 models for the given model. |
| 59 """ |
| 60 return { |
| 61 (rel_mod._meta.app_label, rel_mod._meta.model_name) |
| 62 for rel_mod in _get_related_models(model) |
| 63 } |
| 64 |
| 65 |
| 66 def get_related_models_recursive(model): |
| 67 """ |
| 68 Return all models that have a direct or indirect relationship |
| 69 to the given model. |
| 70 |
| 71 Relationships are either defined by explicit relational fields, like |
| 72 ForeignKey, ManyToManyField or OneToOneField, or by inheriting from another |
| 73 model (a superclass is related to its subclasses, but not vice versa). Note, |
| 74 however, that a model inheriting from a concrete model is also related to |
| 75 its superclass through the implicit *_ptr OneToOneField on the subclass. |
| 76 """ |
| 77 seen = set() |
| 78 queue = _get_related_models(model) |
| 79 for rel_mod in queue: |
| 80 rel_app_label, rel_model_name = rel_mod._meta.app_label, rel_mod._meta.m
odel_name |
| 81 if (rel_app_label, rel_model_name) in seen: |
| 82 continue |
| 83 seen.add((rel_app_label, rel_model_name)) |
| 84 queue.extend(_get_related_models(rel_mod)) |
| 85 return seen - {(model._meta.app_label, model._meta.model_name)} |
| 86 |
| 87 |
| 88 class ProjectState(object): |
| 89 """ |
| 90 Represents the entire project's overall state. |
| 91 This is the item that is passed around - we do it here rather than at the |
| 92 app level so that cross-app FKs/etc. resolve properly. |
| 93 """ |
| 94 |
| 95 def __init__(self, models=None, real_apps=None): |
| 96 self.models = models or {} |
| 97 # Apps to include from main registry, usually unmigrated ones |
| 98 self.real_apps = real_apps or [] |
| 99 self.is_delayed = False |
| 100 |
| 101 def add_model(self, model_state): |
| 102 app_label, model_name = model_state.app_label, model_state.name_lower |
| 103 self.models[(app_label, model_name)] = model_state |
| 104 if 'apps' in self.__dict__: # hasattr would cache the property |
| 105 self.reload_model(app_label, model_name) |
| 106 |
| 107 def remove_model(self, app_label, model_name): |
| 108 del self.models[app_label, model_name] |
| 109 if 'apps' in self.__dict__: # hasattr would cache the property |
| 110 self.apps.unregister_model(app_label, model_name) |
| 111 # Need to do this explicitly since unregister_model() doesn't clear |
| 112 # the cache automatically (#24513) |
| 113 self.apps.clear_cache() |
| 114 |
| 115 def _find_reload_model(self, app_label, model_name, delay=False): |
| 116 if delay: |
| 117 self.is_delayed = True |
| 118 |
| 119 related_models = set() |
| 120 |
| 121 try: |
| 122 old_model = self.apps.get_model(app_label, model_name) |
| 123 except LookupError: |
| 124 pass |
| 125 else: |
| 126 # Get all relations to and from the old model before reloading, |
| 127 # as _meta.apps may change |
| 128 if delay: |
| 129 related_models = get_related_models_tuples(old_model) |
| 130 else: |
| 131 related_models = get_related_models_recursive(old_model) |
| 132 |
| 133 # Get all outgoing references from the model to be rendered |
| 134 model_state = self.models[(app_label, model_name)] |
| 135 # Directly related models are the models pointed to by ForeignKeys, |
| 136 # OneToOneFields, and ManyToManyFields. |
| 137 direct_related_models = set() |
| 138 for name, field in model_state.fields: |
| 139 if field.is_relation: |
| 140 if field.remote_field.model == RECURSIVE_RELATIONSHIP_CONSTANT: |
| 141 continue |
| 142 rel_app_label, rel_model_name = _get_app_label_and_model_name(fi
eld.related_model, app_label) |
| 143 direct_related_models.add((rel_app_label, rel_model_name.lower()
)) |
| 144 |
| 145 # For all direct related models recursively get all related models. |
| 146 related_models.update(direct_related_models) |
| 147 for rel_app_label, rel_model_name in direct_related_models: |
| 148 try: |
| 149 rel_model = self.apps.get_model(rel_app_label, rel_model_name) |
| 150 except LookupError: |
| 151 pass |
| 152 else: |
| 153 if delay: |
| 154 related_models.update(get_related_models_tuples(rel_model)) |
| 155 else: |
| 156 related_models.update(get_related_models_recursive(rel_model
)) |
| 157 |
| 158 # Include the model itself |
| 159 related_models.add((app_label, model_name)) |
| 160 |
| 161 return related_models |
| 162 |
| 163 def reload_model(self, app_label, model_name, delay=False): |
| 164 if 'apps' in self.__dict__: # hasattr would cache the property |
| 165 related_models = self._find_reload_model(app_label, model_name, dela
y) |
| 166 self._reload(related_models) |
| 167 |
| 168 def reload_models(self, models, delay=True): |
| 169 if 'apps' in self.__dict__: # hasattr would cache the property |
| 170 related_models = set() |
| 171 for app_label, model_name in models: |
| 172 related_models.update(self._find_reload_model(app_label, model_n
ame, delay)) |
| 173 self._reload(related_models) |
| 174 |
| 175 def _reload(self, related_models): |
| 176 # Unregister all related models |
| 177 with self.apps.bulk_update(): |
| 178 for rel_app_label, rel_model_name in related_models: |
| 179 self.apps.unregister_model(rel_app_label, rel_model_name) |
| 180 |
| 181 states_to_be_rendered = [] |
| 182 # Gather all models states of those models that will be rerendered. |
| 183 # This includes: |
| 184 # 1. All related models of unmigrated apps |
| 185 for model_state in self.apps.real_models: |
| 186 if (model_state.app_label, model_state.name_lower) in related_models
: |
| 187 states_to_be_rendered.append(model_state) |
| 188 |
| 189 # 2. All related models of migrated apps |
| 190 for rel_app_label, rel_model_name in related_models: |
| 191 try: |
| 192 model_state = self.models[rel_app_label, rel_model_name] |
| 193 except KeyError: |
| 194 pass |
| 195 else: |
| 196 states_to_be_rendered.append(model_state) |
| 197 |
| 198 # Render all models |
| 199 self.apps.render_multiple(states_to_be_rendered) |
| 200 |
| 201 def clone(self): |
| 202 "Returns an exact copy of this ProjectState" |
| 203 new_state = ProjectState( |
| 204 models={k: v.clone() for k, v in self.models.items()}, |
| 205 real_apps=self.real_apps, |
| 206 ) |
| 207 if 'apps' in self.__dict__: |
| 208 new_state.apps = self.apps.clone() |
| 209 new_state.is_delayed = self.is_delayed |
| 210 return new_state |
| 211 |
| 212 def clear_delayed_apps_cache(self): |
| 213 if self.is_delayed and 'apps' in self.__dict__: |
| 214 del self.__dict__['apps'] |
| 215 |
| 216 @cached_property |
| 217 def apps(self): |
| 218 return StateApps(self.real_apps, self.models) |
| 219 |
| 220 @property |
| 221 def concrete_apps(self): |
| 222 self.apps = StateApps(self.real_apps, self.models, ignore_swappable=True
) |
| 223 return self.apps |
| 224 |
| 225 @classmethod |
| 226 def from_apps(cls, apps): |
| 227 "Takes in an Apps and returns a ProjectState matching it" |
| 228 app_models = {} |
| 229 for model in apps.get_models(include_swapped=True): |
| 230 model_state = ModelState.from_model(model) |
| 231 app_models[(model_state.app_label, model_state.name_lower)] = model_
state |
| 232 return cls(app_models) |
| 233 |
| 234 def __eq__(self, other): |
| 235 if set(self.models.keys()) != set(other.models.keys()): |
| 236 return False |
| 237 if set(self.real_apps) != set(other.real_apps): |
| 238 return False |
| 239 return all(model == other.models[key] for key, model in self.models.item
s()) |
| 240 |
| 241 def __ne__(self, other): |
| 242 return not (self == other) |
| 243 |
| 244 |
| 245 class AppConfigStub(AppConfig): |
| 246 """ |
| 247 Stubs a Django AppConfig. Only provides a label, and a dict of models. |
| 248 """ |
| 249 # Not used, but required by AppConfig.__init__ |
| 250 path = '' |
| 251 |
| 252 def __init__(self, label): |
| 253 self.label = label |
| 254 # App-label and app-name are not the same thing, so technically passing |
| 255 # in the label here is wrong. In practice, migrations don't care about |
| 256 # the app name, but we need something unique, and the label works fine. |
| 257 super(AppConfigStub, self).__init__(label, None) |
| 258 |
| 259 def import_models(self): |
| 260 self.models = self.apps.all_models[self.label] |
| 261 |
| 262 |
| 263 class StateApps(Apps): |
| 264 """ |
| 265 Subclass of the global Apps registry class to better handle dynamic model |
| 266 additions and removals. |
| 267 """ |
| 268 def __init__(self, real_apps, models, ignore_swappable=False): |
| 269 # Any apps in self.real_apps should have all their models included |
| 270 # in the render. We don't use the original model instances as there |
| 271 # are some variables that refer to the Apps object. |
| 272 # FKs/M2Ms from real apps are also not included as they just |
| 273 # mess things up with partial states (due to lack of dependencies) |
| 274 self.real_models = [] |
| 275 for app_label in real_apps: |
| 276 app = global_apps.get_app_config(app_label) |
| 277 for model in app.get_models(): |
| 278 self.real_models.append(ModelState.from_model(model, exclude_rel
s=True)) |
| 279 # Populate the app registry with a stub for each application. |
| 280 app_labels = {model_state.app_label for model_state in models.values()} |
| 281 app_configs = [AppConfigStub(label) for label in sorted(real_apps + list
(app_labels))] |
| 282 super(StateApps, self).__init__(app_configs) |
| 283 |
| 284 # The lock gets in the way of copying as implemented in clone(), which |
| 285 # is called whenever Django duplicates a StateApps before updating it. |
| 286 self._lock = None |
| 287 |
| 288 self.render_multiple(list(models.values()) + self.real_models) |
| 289 |
| 290 # There shouldn't be any operations pending at this point. |
| 291 from django.core.checks.model_checks import _check_lazy_references |
| 292 ignore = {make_model_tuple(settings.AUTH_USER_MODEL)} if ignore_swappabl
e else set() |
| 293 errors = _check_lazy_references(self, ignore=ignore) |
| 294 if errors: |
| 295 raise ValueError("\n".join(error.msg for error in errors)) |
| 296 |
| 297 @contextmanager |
| 298 def bulk_update(self): |
| 299 # Avoid clearing each model's cache for each change. Instead, clear |
| 300 # all caches when we're finished updating the model instances. |
| 301 ready = self.ready |
| 302 self.ready = False |
| 303 try: |
| 304 yield |
| 305 finally: |
| 306 self.ready = ready |
| 307 self.clear_cache() |
| 308 |
| 309 def render_multiple(self, model_states): |
| 310 # We keep trying to render the models in a loop, ignoring invalid |
| 311 # base errors, until the size of the unrendered models doesn't |
| 312 # decrease by at least one, meaning there's a base dependency loop/ |
| 313 # missing base. |
| 314 if not model_states: |
| 315 return |
| 316 # Prevent that all model caches are expired for each render. |
| 317 with self.bulk_update(): |
| 318 unrendered_models = model_states |
| 319 while unrendered_models: |
| 320 new_unrendered_models = [] |
| 321 for model in unrendered_models: |
| 322 try: |
| 323 model.render(self) |
| 324 except InvalidBasesError: |
| 325 new_unrendered_models.append(model) |
| 326 if len(new_unrendered_models) == len(unrendered_models): |
| 327 raise InvalidBasesError( |
| 328 "Cannot resolve bases for %r\nThis can happen if you are
inheriting models from an " |
| 329 "app with migrations (e.g. contrib.auth)\n in an app wit
h no migrations; see " |
| 330 "https://docs.djangoproject.com/en/%s/topics/migrations/
#dependencies " |
| 331 "for more" % (new_unrendered_models, get_docs_version()) |
| 332 ) |
| 333 unrendered_models = new_unrendered_models |
| 334 |
| 335 def clone(self): |
| 336 """ |
| 337 Return a clone of this registry, mainly used by the migration framework. |
| 338 """ |
| 339 clone = StateApps([], {}) |
| 340 clone.all_models = copy.deepcopy(self.all_models) |
| 341 clone.app_configs = copy.deepcopy(self.app_configs) |
| 342 # Set the pointer to the correct app registry. |
| 343 for app_config in clone.app_configs.values(): |
| 344 app_config.apps = clone |
| 345 # No need to actually clone them, they'll never change |
| 346 clone.real_models = self.real_models |
| 347 return clone |
| 348 |
| 349 def register_model(self, app_label, model): |
| 350 self.all_models[app_label][model._meta.model_name] = model |
| 351 if app_label not in self.app_configs: |
| 352 self.app_configs[app_label] = AppConfigStub(app_label) |
| 353 self.app_configs[app_label].apps = self |
| 354 self.app_configs[app_label].models = OrderedDict() |
| 355 self.app_configs[app_label].models[model._meta.model_name] = model |
| 356 self.do_pending_operations(model) |
| 357 self.clear_cache() |
| 358 |
| 359 def unregister_model(self, app_label, model_name): |
| 360 try: |
| 361 del self.all_models[app_label][model_name] |
| 362 del self.app_configs[app_label].models[model_name] |
| 363 except KeyError: |
| 364 pass |
| 365 |
| 366 |
| 367 class ModelState(object): |
| 368 """ |
| 369 Represents a Django Model. We don't use the actual Model class |
| 370 as it's not designed to have its options changed - instead, we |
| 371 mutate this one and then render it into a Model as required. |
| 372 |
| 373 Note that while you are allowed to mutate .fields, you are not allowed |
| 374 to mutate the Field instances inside there themselves - you must instead |
| 375 assign new ones, as these are not detached during a clone. |
| 376 """ |
| 377 |
| 378 def __init__(self, app_label, name, fields, options=None, bases=None, manage
rs=None): |
| 379 self.app_label = app_label |
| 380 self.name = force_text(name) |
| 381 self.fields = fields |
| 382 self.options = options or {} |
| 383 self.options.setdefault('indexes', []) |
| 384 self.bases = bases or (models.Model, ) |
| 385 self.managers = managers or [] |
| 386 # Sanity-check that fields is NOT a dict. It must be ordered. |
| 387 if isinstance(self.fields, dict): |
| 388 raise ValueError("ModelState.fields cannot be a dict - it must be a
list of 2-tuples.") |
| 389 for name, field in fields: |
| 390 # Sanity-check that fields are NOT already bound to a model. |
| 391 if hasattr(field, 'model'): |
| 392 raise ValueError( |
| 393 'ModelState.fields cannot be bound to a model - "%s" is.' %
name |
| 394 ) |
| 395 # Sanity-check that relation fields are NOT referring to a model cla
ss. |
| 396 if field.is_relation and hasattr(field.related_model, '_meta'): |
| 397 raise ValueError( |
| 398 'ModelState.fields cannot refer to a model class - "%s.to" d
oes. ' |
| 399 'Use a string reference instead.' % name |
| 400 ) |
| 401 if field.many_to_many and hasattr(field.remote_field.through, '_meta
'): |
| 402 raise ValueError( |
| 403 'ModelState.fields cannot refer to a model class - "%s.throu
gh" does. ' |
| 404 'Use a string reference instead.' % name |
| 405 ) |
| 406 # Sanity-check that indexes have their name set. |
| 407 for index in self.options['indexes']: |
| 408 if not index.name: |
| 409 raise ValueError( |
| 410 "Indexes passed to ModelState require a name attribute. " |
| 411 "%r doesn't have one." % index |
| 412 ) |
| 413 |
| 414 @cached_property |
| 415 def name_lower(self): |
| 416 return self.name.lower() |
| 417 |
| 418 @classmethod |
| 419 def from_model(cls, model, exclude_rels=False): |
| 420 """ |
| 421 Feed me a model, get a ModelState representing it out. |
| 422 """ |
| 423 # Deconstruct the fields |
| 424 fields = [] |
| 425 for field in model._meta.local_fields: |
| 426 if getattr(field, "remote_field", None) and exclude_rels: |
| 427 continue |
| 428 if isinstance(field, OrderWrt): |
| 429 continue |
| 430 name = force_text(field.name, strings_only=True) |
| 431 try: |
| 432 fields.append((name, field.clone())) |
| 433 except TypeError as e: |
| 434 raise TypeError("Couldn't reconstruct field %s on %s: %s" % ( |
| 435 name, |
| 436 model._meta.label, |
| 437 e, |
| 438 )) |
| 439 if not exclude_rels: |
| 440 for field in model._meta.local_many_to_many: |
| 441 name = force_text(field.name, strings_only=True) |
| 442 try: |
| 443 fields.append((name, field.clone())) |
| 444 except TypeError as e: |
| 445 raise TypeError("Couldn't reconstruct m2m field %s on %s: %s
" % ( |
| 446 name, |
| 447 model._meta.object_name, |
| 448 e, |
| 449 )) |
| 450 # Extract the options |
| 451 options = {} |
| 452 for name in DEFAULT_NAMES: |
| 453 # Ignore some special options |
| 454 if name in ["apps", "app_label"]: |
| 455 continue |
| 456 elif name in model._meta.original_attrs: |
| 457 if name == "unique_together": |
| 458 ut = model._meta.original_attrs["unique_together"] |
| 459 options[name] = set(normalize_together(ut)) |
| 460 elif name == "index_together": |
| 461 it = model._meta.original_attrs["index_together"] |
| 462 options[name] = set(normalize_together(it)) |
| 463 elif name == "indexes": |
| 464 indexes = [idx.clone() for idx in model._meta.indexes] |
| 465 for index in indexes: |
| 466 if not index.name: |
| 467 index.set_name_with_model(model) |
| 468 options['indexes'] = indexes |
| 469 else: |
| 470 options[name] = model._meta.original_attrs[name] |
| 471 # Force-convert all options to text_type (#23226) |
| 472 options = cls.force_text_recursive(options) |
| 473 # If we're ignoring relationships, remove all field-listing model |
| 474 # options (that option basically just means "make a stub model") |
| 475 if exclude_rels: |
| 476 for key in ["unique_together", "index_together", "order_with_respect
_to"]: |
| 477 if key in options: |
| 478 del options[key] |
| 479 # Private fields are ignored, so remove options that refer to them. |
| 480 elif options.get('order_with_respect_to') in {field.name for field in mo
del._meta.private_fields}: |
| 481 del options['order_with_respect_to'] |
| 482 |
| 483 def flatten_bases(model): |
| 484 bases = [] |
| 485 for base in model.__bases__: |
| 486 if hasattr(base, "_meta") and base._meta.abstract: |
| 487 bases.extend(flatten_bases(base)) |
| 488 else: |
| 489 bases.append(base) |
| 490 return bases |
| 491 |
| 492 # We can't rely on __mro__ directly because we only want to flatten |
| 493 # abstract models and not the whole tree. However by recursing on |
| 494 # __bases__ we may end up with duplicates and ordering issues, we |
| 495 # therefore discard any duplicates and reorder the bases according |
| 496 # to their index in the MRO. |
| 497 flattened_bases = sorted(set(flatten_bases(model)), key=lambda x: model.
__mro__.index(x)) |
| 498 |
| 499 # Make our record |
| 500 bases = tuple( |
| 501 ( |
| 502 base._meta.label_lower |
| 503 if hasattr(base, "_meta") else |
| 504 base |
| 505 ) |
| 506 for base in flattened_bases |
| 507 ) |
| 508 # Ensure at least one base inherits from models.Model |
| 509 if not any((isinstance(base, six.string_types) or issubclass(base, model
s.Model)) for base in bases): |
| 510 bases = (models.Model,) |
| 511 |
| 512 managers = [] |
| 513 manager_names = set() |
| 514 default_manager_shim = None |
| 515 for manager in model._meta.managers: |
| 516 manager_name = force_text(manager.name) |
| 517 if manager_name in manager_names: |
| 518 # Skip overridden managers. |
| 519 continue |
| 520 elif manager.use_in_migrations: |
| 521 # Copy managers usable in migrations. |
| 522 new_manager = copy.copy(manager) |
| 523 new_manager._set_creation_counter() |
| 524 elif manager is model._base_manager or manager is model._default_man
ager: |
| 525 # Shim custom managers used as default and base managers. |
| 526 new_manager = models.Manager() |
| 527 new_manager.model = manager.model |
| 528 new_manager.name = manager.name |
| 529 if manager is model._default_manager: |
| 530 default_manager_shim = new_manager |
| 531 else: |
| 532 continue |
| 533 manager_names.add(manager_name) |
| 534 managers.append((manager_name, new_manager)) |
| 535 |
| 536 # Ignore a shimmed default manager called objects if it's the only one. |
| 537 if managers == [('objects', default_manager_shim)]: |
| 538 managers = [] |
| 539 |
| 540 # Construct the new ModelState |
| 541 return cls( |
| 542 model._meta.app_label, |
| 543 model._meta.object_name, |
| 544 fields, |
| 545 options, |
| 546 bases, |
| 547 managers, |
| 548 ) |
| 549 |
| 550 @classmethod |
| 551 def force_text_recursive(cls, value): |
| 552 if isinstance(value, six.string_types): |
| 553 return force_text(value) |
| 554 elif isinstance(value, list): |
| 555 return [cls.force_text_recursive(x) for x in value] |
| 556 elif isinstance(value, tuple): |
| 557 return tuple(cls.force_text_recursive(x) for x in value) |
| 558 elif isinstance(value, set): |
| 559 return set(cls.force_text_recursive(x) for x in value) |
| 560 elif isinstance(value, dict): |
| 561 return { |
| 562 cls.force_text_recursive(k): cls.force_text_recursive(v) |
| 563 for k, v in value.items() |
| 564 } |
| 565 return value |
| 566 |
| 567 def construct_managers(self): |
| 568 "Deep-clone the managers using deconstruction" |
| 569 # Sort all managers by their creation counter |
| 570 sorted_managers = sorted(self.managers, key=lambda v: v[1].creation_coun
ter) |
| 571 for mgr_name, manager in sorted_managers: |
| 572 mgr_name = force_text(mgr_name) |
| 573 as_manager, manager_path, qs_path, args, kwargs = manager.deconstruc
t() |
| 574 if as_manager: |
| 575 qs_class = import_string(qs_path) |
| 576 yield mgr_name, qs_class.as_manager() |
| 577 else: |
| 578 manager_class = import_string(manager_path) |
| 579 yield mgr_name, manager_class(*args, **kwargs) |
| 580 |
| 581 def clone(self): |
| 582 "Returns an exact copy of this ModelState" |
| 583 return self.__class__( |
| 584 app_label=self.app_label, |
| 585 name=self.name, |
| 586 fields=list(self.fields), |
| 587 # Since options are shallow-copied here, operations such as |
| 588 # AddIndex must replace their option (e.g 'indexes') rather |
| 589 # than mutating it. |
| 590 options=dict(self.options), |
| 591 bases=self.bases, |
| 592 managers=list(self.managers), |
| 593 ) |
| 594 |
| 595 def render(self, apps): |
| 596 "Creates a Model object from our current state into the given apps" |
| 597 # First, make a Meta object |
| 598 meta_contents = {'app_label': self.app_label, "apps": apps} |
| 599 meta_contents.update(self.options) |
| 600 meta = type(str("Meta"), tuple(), meta_contents) |
| 601 # Then, work out our bases |
| 602 try: |
| 603 bases = tuple( |
| 604 (apps.get_model(base) if isinstance(base, six.string_types) else
base) |
| 605 for base in self.bases |
| 606 ) |
| 607 except LookupError: |
| 608 raise InvalidBasesError("Cannot resolve one or more bases from %r" %
(self.bases,)) |
| 609 # Turn fields into a dict for the body, add other bits |
| 610 body = {name: field.clone() for name, field in self.fields} |
| 611 body['Meta'] = meta |
| 612 body['__module__'] = "__fake__" |
| 613 |
| 614 # Restore managers |
| 615 body.update(self.construct_managers()) |
| 616 |
| 617 with warnings.catch_warnings(): |
| 618 warnings.filterwarnings( |
| 619 "ignore", "Managers from concrete parents will soon qualify as d
efault managers", |
| 620 RemovedInDjango20Warning) |
| 621 |
| 622 # Then, make a Model object (apps.register_model is called in __new_
_) |
| 623 return type( |
| 624 str(self.name), |
| 625 bases, |
| 626 body, |
| 627 ) |
| 628 |
| 629 def get_field_by_name(self, name): |
| 630 for fname, field in self.fields: |
| 631 if fname == name: |
| 632 return field |
| 633 raise ValueError("No field called %s on model %s" % (name, self.name)) |
| 634 |
| 635 def get_index_by_name(self, name): |
| 636 for index in self.options['indexes']: |
| 637 if index.name == name: |
| 638 return index |
| 639 raise ValueError("No index named %s on model %s" % (name, self.name)) |
| 640 |
| 641 def __repr__(self): |
| 642 return "<%s: '%s.%s'>" % (self.__class__.__name__, self.app_label, self.
name) |
| 643 |
| 644 def __eq__(self, other): |
| 645 return ( |
| 646 (self.app_label == other.app_label) and |
| 647 (self.name == other.name) and |
| 648 (len(self.fields) == len(other.fields)) and |
| 649 all((k1 == k2 and (f1.deconstruct()[1:] == f2.deconstruct()[1:])) |
| 650 for (k1, f1), (k2, f2) in zip(self.fields, other.fields)) and |
| 651 (self.options == other.options) and |
| 652 (self.bases == other.bases) and |
| 653 (self.managers == other.managers) |
| 654 ) |
| 655 |
| 656 def __ne__(self, other): |
| 657 return not (self == other) |
OLD | NEW |