diff -r 8d941af65caf -r 77b6da96e6f1 web/lib/django/db/models/loading.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/web/lib/django/db/models/loading.py Wed Jun 02 18:57:35 2010 +0200 @@ -0,0 +1,227 @@ +"Utilities for loading models and the modules that contain them." + +from django.conf import settings +from django.core.exceptions import ImproperlyConfigured +from django.utils.datastructures import SortedDict +from django.utils.importlib import import_module +from django.utils.module_loading import module_has_submodule + +import imp +import sys +import os +import threading + +__all__ = ('get_apps', 'get_app', 'get_models', 'get_model', 'register_models', + 'load_app', 'app_cache_ready') + +class AppCache(object): + """ + A cache that stores installed applications and their models. Used to + provide reverse-relations and for app introspection (e.g. admin). + """ + # Use the Borg pattern to share state between all instances. Details at + # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/66531. + __shared_state = dict( + # Keys of app_store are the model modules for each application. + app_store = SortedDict(), + + # Mapping of app_labels to a dictionary of model names to model code. + app_models = SortedDict(), + + # Mapping of app_labels to errors raised when trying to import the app. + app_errors = {}, + + # -- Everything below here is only used when populating the cache -- + loaded = False, + handled = {}, + postponed = [], + nesting_level = 0, + write_lock = threading.RLock(), + _get_models_cache = {}, + ) + + def __init__(self): + self.__dict__ = self.__shared_state + + def _populate(self): + """ + Fill in all the cache information. This method is threadsafe, in the + sense that every caller will see the same state upon return, and if the + cache is already initialised, it does no work. + """ + if self.loaded: + return + self.write_lock.acquire() + try: + if self.loaded: + return + for app_name in settings.INSTALLED_APPS: + if app_name in self.handled: + continue + self.load_app(app_name, True) + if not self.nesting_level: + for app_name in self.postponed: + self.load_app(app_name) + self.loaded = True + finally: + self.write_lock.release() + + def load_app(self, app_name, can_postpone=False): + """ + Loads the app with the provided fully qualified name, and returns the + model module. + """ + self.handled[app_name] = None + self.nesting_level += 1 + app_module = import_module(app_name) + try: + models = import_module('.models', app_name) + except ImportError: + self.nesting_level -= 1 + # If the app doesn't have a models module, we can just ignore the + # ImportError and return no models for it. + if not module_has_submodule(app_module, 'models'): + return None + # But if the app does have a models module, we need to figure out + # whether to suppress or propagate the error. If can_postpone is + # True then it may be that the package is still being imported by + # Python and the models module isn't available yet. So we add the + # app to the postponed list and we'll try it again after all the + # recursion has finished (in populate). If can_postpone is False + # then it's time to raise the ImportError. + else: + if can_postpone: + self.postponed.append(app_name) + return None + else: + raise + + self.nesting_level -= 1 + if models not in self.app_store: + self.app_store[models] = len(self.app_store) + return models + + def app_cache_ready(self): + """ + Returns true if the model cache is fully populated. + + Useful for code that wants to cache the results of get_models() for + themselves once it is safe to do so. + """ + return self.loaded + + def get_apps(self): + "Returns a list of all installed modules that contain models." + self._populate() + + # Ensure the returned list is always in the same order (with new apps + # added at the end). This avoids unstable ordering on the admin app + # list page, for example. + apps = [(v, k) for k, v in self.app_store.items()] + apps.sort() + return [elt[1] for elt in apps] + + def get_app(self, app_label, emptyOK=False): + """ + Returns the module containing the models for the given app_label. If + the app has no models in it and 'emptyOK' is True, returns None. + """ + self._populate() + self.write_lock.acquire() + try: + for app_name in settings.INSTALLED_APPS: + if app_label == app_name.split('.')[-1]: + mod = self.load_app(app_name, False) + if mod is None: + if emptyOK: + return None + else: + return mod + raise ImproperlyConfigured("App with label %s could not be found" % app_label) + finally: + self.write_lock.release() + + def get_app_errors(self): + "Returns the map of known problems with the INSTALLED_APPS." + self._populate() + return self.app_errors + + def get_models(self, app_mod=None, include_auto_created=False, include_deferred=False): + """ + Given a module containing models, returns a list of the models. + Otherwise returns a list of all installed models. + + By default, auto-created models (i.e., m2m models without an + explicit intermediate table) are not included. However, if you + specify include_auto_created=True, they will be. + + By default, models created to satisfy deferred attribute + queries are *not* included in the list of models. However, if + you specify include_deferred, they will be. + """ + cache_key = (app_mod, include_auto_created, include_deferred) + try: + return self._get_models_cache[cache_key] + except KeyError: + pass + self._populate() + if app_mod: + app_list = [self.app_models.get(app_mod.__name__.split('.')[-2], SortedDict())] + else: + app_list = self.app_models.itervalues() + model_list = [] + for app in app_list: + model_list.extend( + model for model in app.values() + if ((not model._deferred or include_deferred) + and (not model._meta.auto_created or include_auto_created)) + ) + self._get_models_cache[cache_key] = model_list + return model_list + + def get_model(self, app_label, model_name, seed_cache=True): + """ + Returns the model matching the given app_label and case-insensitive + model_name. + + Returns None if no model is found. + """ + if seed_cache: + self._populate() + return self.app_models.get(app_label, SortedDict()).get(model_name.lower()) + + def register_models(self, app_label, *models): + """ + Register a set of models as belonging to an app. + """ + for model in models: + # Store as 'name: model' pair in a dictionary + # in the app_models dictionary + model_name = model._meta.object_name.lower() + model_dict = self.app_models.setdefault(app_label, SortedDict()) + if model_name in model_dict: + # The same model may be imported via different paths (e.g. + # appname.models and project.appname.models). We use the source + # filename as a means to detect identity. + fname1 = os.path.abspath(sys.modules[model.__module__].__file__) + fname2 = os.path.abspath(sys.modules[model_dict[model_name].__module__].__file__) + # Since the filename extension could be .py the first time and + # .pyc or .pyo the second time, ignore the extension when + # comparing. + if os.path.splitext(fname1)[0] == os.path.splitext(fname2)[0]: + continue + model_dict[model_name] = model + self._get_models_cache.clear() + +cache = AppCache() + +# These methods were always module level, so are kept that way for backwards +# compatibility. +get_apps = cache.get_apps +get_app = cache.get_app +get_app_errors = cache.get_app_errors +get_models = cache.get_models +get_model = cache.get_model +register_models = cache.register_models +load_app = cache.load_app +app_cache_ready = cache.app_cache_ready