def autodiscover(): for app_name in settings.INSTALLED_APPS: app = import_module(app_name) if module_has_submodule(app, 'serializers'): import_module(app_name + '.serializers') for app_name in settings.INSTALLED_APPS: app = import_module(app_name) if module_has_submodule(app, 'views'): import_module(app_name + '.views')
def test_has_sumbodule_with_dotted_path(self): """Nested module existence can be tested.""" test_module = import_module('utils_tests.test_module') # A grandchild that exists. self.assertIs(module_has_submodule(test_module, 'child_module.grandchild_module'), True) # A grandchild that doesn't exist. self.assertIs(module_has_submodule(test_module, 'child_module.no_such_module'), False) # A grandchild whose parent doesn't exist. self.assertIs(module_has_submodule(test_module, 'no_such_module.grandchild_module'), False) # A grandchild whose parent is not a package. self.assertIs(module_has_submodule(test_module, 'good_module.no_such_module'), False)
def autodiscover(): for app in settings.INSTALLED_APPS: mod = import_module(app) if module_has_submodule(mod, 'models'): if not module_has_submodule(mod, 'admin'): models = import_module('%s.models' % app) for model in get_models(models): try: admin.site.register(model) except AlreadyRegistered: pass else: import_module('%s.admin' % app)
def autodiscover_models(given_app=None, given_model=None): """ Autodiscover `fakers` modules and `ModelFaker` subclasses `given_app` can be given to restrict autodiscovering `given_model` can be given to fake only one model """ if given_model and not given_app: raise ImproperlyConfigured("If model is given, app must be given too ") # Autodiscover fakers apps = given_app and [given_app] or settings.INSTALLED_APPS for app in apps: mod = import_module(app) # Attempt to import the app's fakers module. if module_has_submodule(mod, 'fakers'): import_module('%s.fakers' % app) models = ModelFaker.__subclasses__() if given_app: module_fakers = getattr(sys.modules.get(given_app), 'fakers') models = [m for m in models if m.__module__.startswith(module_fakers.__name__)] if given_model: models = [getattr(module_fakers, given_model)] return models
def autodiscover(): """ Auto-discover INSTALLED_APPS ophandler.py modules and fail silently when not present. This forces an import on them to register any handler bits they may want. """ import copy from django.conf import settings from django.utils.importlib import import_module from django.utils.module_loading import module_has_submodule handler_module_name = settings.OBJECT_PERMISSION_HANDLER_MODULE_NAME for app in settings.INSTALLED_APPS: mod = import_module(app) # Attempt to import the app's object permission handler module. try: before_import_registry = copy.copy(site._registry) import_module('%s.%s' % (app, handler_module_name)) except: # Reset the model registry to the state before the last import as # this import will have to reoccur on the next request and this # could raise NotRegistered and AlreadyRegistered exceptions site._registry = before_import_registry # Decide wheter to bubble up this error. If the app just # doesn't have an object permission module, we can ignore the error # attempting to import it, otherwise we want it to bubble up. if module_has_submodule(mod, handler_module_name): raise
def autodiscover(): """ Iterate over django.apps.get_app_configs() and discover versatileimagefield.py modules. """ from importlib import import_module from django.apps import apps from django.utils.module_loading import module_has_submodule for app_config in apps.get_app_configs(): # Attempt to import the app's module. try: before_import_sizedimage_registry = copy.copy( versatileimagefield_registry._sizedimage_registry ) before_import_filter_registry = copy.copy( versatileimagefield_registry._filter_registry ) import_module('%s.versatileimagefield' % app_config.name) except: # Reset the versatileimagefield_registry to the state before the # last import as this import will have to reoccur on the next # request and this could raise NotRegistered and AlreadyRegistered # exceptions (see django ticket #8245). versatileimagefield_registry._sizedimage_registry = \ before_import_sizedimage_registry versatileimagefield_registry._filter_registry = \ before_import_filter_registry # Decide whether to bubble up this error. If the app just # doesn't have the module in question, we can ignore the error # attempting to import it, otherwise we want it to bubble up. if module_has_submodule(app_config.module, 'versatileimagefield'): raise
def get_app_modules(self, apps): """return array of imported leonardo modules for apps """ modules = getattr(self, "_modules", []) if not modules: from django.utils.module_loading import module_has_submodule # Try importing a modules from the module package package_string = '.'.join(['leonardo', 'module']) for app in apps: exc = '...' try: # check if is not full app _app = import_module(app) except Exception as e: _app = False exc = e if module_has_submodule( import_module(package_string), app) or _app: if _app: mod = _app else: mod = import_module('.{0}'.format(app), package_string) if mod: modules.append(mod) continue warnings.warn('%s was skipped because %s ' % (app, exc)) self._modules = modules return self._modules
def get_callable(lookup_view, can_fail=False): """ Convert a string version of a function name to the callable object. If the lookup_view is not an import path, it is assumed to be a URL pattern label and the original string is returned. If can_fail is True, lookup_view might be a URL pattern label, so errors during the import fail and the string is returned. """ if not callable(lookup_view): mod_name, func_name = get_mod_func(lookup_view) try: if func_name != "": lookup_view = getattr(import_module(mod_name), func_name) if not callable(lookup_view): raise ViewDoesNotExist("Could not import %s.%s. View is not callable." % (mod_name, func_name)) except AttributeError: if not can_fail: raise ViewDoesNotExist( "Could not import %s. View does not exist in module %s." % (lookup_view, mod_name) ) except ImportError: parentmod, submod = get_mod_func(mod_name) if not can_fail and submod != "" and not module_has_submodule(import_module(parentmod), submod): raise ViewDoesNotExist( "Could not import %s. Parent module %s does not exist." % (lookup_view, mod_name) ) if not can_fail: raise return lookup_view
def autodiscover(): """ Auto-discover INSTALLED_APPS report.py modules and fail silently when not present. Borrowed form django.contrib.admin """ from django.utils.importlib import import_module from django.utils.module_loading import module_has_submodule global reports for app in settings.INSTALLED_APPS: mod = import_module(app) # Attempt to import the app's admin module. try: before_import_registry = copy.copy(reports) import_module('%s.reports' % app) except: # Reset the model registry to the state before the last import as # this import will have to reoccur on the next request and this # could raise NotRegistered and AlreadyRegistered exceptions # (see #8245). reports = before_import_registry # Decide whether to bubble up this error. If the app just # doesn't have an admin module, we can ignore the error # attempting to import it, otherwise we want it to bubble up. if module_has_submodule(mod, 'reports'): raise
def get_notifications(user): notifications = {} for app in settings.INSTALLED_APPS: mod = import_module(app) try: submod = import_module('%s.notifications' % app) except: if module_has_submodule(mod, 'notifications'): raise continue for name in dir(submod): attr = getattr(submod, name) if isinstance(attr, NotificationTemplate): if attr.staff_only and not user.is_staff: continue if isinstance(attr.perms, (list, tuple)): if any(attr.perms) and not user.has_perms(attr.perms): continue notifications[(app, name)] = attr.label or name.replace('_', ' ').capitalize() return notifications.items()
def autodiscover(): """ Auto-discover INSTALLED_APPS backends.py modules that inherit from GenericSocialUserBackend and fail silently when not present. This forces an import on them to register any backend classes. """ from copy import copy from django.conf import settings from django.contrib.admin.sites import site from django.utils.importlib import import_module from django.utils.module_loading import module_has_submodule for app in settings.INSTALLED_APPS: mod = import_module(app) # Attempt to import the app's email module. try: before_import_registry = copy(site._registry) import_module('%s.backends' % app) except Exception, exc: # Reset the model registry to the state before the last import as # this import will have to reoccur on the next request and this # could raise NotRegistered and AlreadyRegistered exceptions # (see #8245). site._registry = before_import_registry # backends exists but import failed, raise the exception. if module_has_submodule(mod, 'backends'): raise Exception( 'Failed to import {0}.backends with error: {1}.'.format( app, exc))
def _init_admin_site(self, extension): """Creates and initializes an admin site for an extension. This creates the admin site and imports the extensions admin module to register the models. The url patterns for the admin site are generated in _install_admin_urls(). """ extension.admin_site = AdminSite(extension.info.app_name) # Import the extension's admin module. try: admin_module_name = '%s.admin' % extension.info.app_name if admin_module_name in sys.modules: # If the extension has been loaded previously and # we are re-enabling it, we must reload the module. # Just importing again will not cause the ModelAdmins # to be registered. reload(sys.modules[admin_module_name]) else: import_module(admin_module_name) except ImportError: mod = import_module(extension.info.app_name) # Decide whether to bubble up this error. If the app just # doesn't have an admin module, we can ignore the error # attempting to import it, otherwise we want it to bubble up. if module_has_submodule(mod, 'admin'): raise ImportError( "Importing admin module for extension %s failed" % extension.info.app_name)
def _autodiscover(registry): """See documentation for autodiscover (without the underscore)""" import copy from django.conf import settings from django.utils.importlib import import_module from django.utils.module_loading import module_has_submodule for app in settings.INSTALLED_APPS: mod = import_module(app) # Attempt to import the app's admin module. try: before_import_registry = copy.copy(registry) import_module('%s.autocomplete_light_registry' % app) except: # Reset the model registry to the state before the last import as # this import will have to reoccur on the next request and this # could raise NotRegistered and AlreadyRegistered exceptions # (see #8245). registry = before_import_registry # Decide whether to bubble up this error. If the app just # doesn't have an admin module, we can ignore the error # attempting to import it, otherwise we want it to bubble up. if module_has_submodule(mod, 'autocomplete_light_registry'): raise
def get_migration_status(**options): # type: (**Any) -> str verbosity = options.get('verbosity', 1) for app_config in apps.get_app_configs(): if module_has_submodule(app_config.module, "management"): import_module('.management', app_config.name) app_labels = [options['app_label']] if options.get('app_label') else None db = options.get('database', DEFAULT_DB_ALIAS) out = StringIO() call_command( 'showmigrations', '--list', app_labels=app_labels, database=db, no_color=options.get('no_color', False), settings=options.get('settings', os.environ['DJANGO_SETTINGS_MODULE']), stdout=out, traceback=options.get('traceback', True), verbosity=verbosity, ) connections.close_all() out.seek(0) output = out.read() return re.sub('\x1b\[(1|0)m', '', output)
def _urls(self): """Constructs the URLconf for Horizon from registered Dashboards.""" urlpatterns = self._get_default_urlpatterns() self._autodiscover() # Discover each dashboard's panels. for dash in self._registry.values(): dash._autodiscover() # Load the plugin-based panel configuration self._load_panel_customization() # Allow for override modules if self._conf.get("customization_module", None): customization_module = self._conf["customization_module"] bits = customization_module.split('.') mod_name = bits.pop() package = '.'.join(bits) mod = import_module(package) try: before_import_registry = copy.copy(self._registry) import_module('%s.%s' % (package, mod_name)) except Exception: self._registry = before_import_registry if module_has_submodule(mod, mod_name): raise # Compile the dynamic urlconf. for dash in self._registry.values(): urlpatterns += patterns('', url(r'^%s/' % dash.slug, include(dash._decorated_urls))) # Return the three arguments to django.conf.urls.include return urlpatterns, self.namespace, self.slug
def load_app(self, app_name, can_postpone=True): """ 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: cron = import_module('.crons', app_name) except ImportError: self.nesting_level -= 1 if not module_has_submodule(app_module, 'crons'): return None else: if can_postpone: self.postponed.append(app_name) return None else: raise self.nesting_level -= 1 if cron not in self.app_store: self.app_store[cron] = len(self.app_store) self.app_labels[self._label_for(cron)] = cron return cron
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.add(app_name) self.nesting_level += 1 app_module = import_module(app_name) try: models = import_module('%s.%s' % (app_name, MODELS_MODULE_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_MODULE_NAME): 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) self.app_labels[self._label_for(models)] = models return models
def register_inner(): """ copy from django.contrib.admin.autodiscover """ import copy from django.utils.importlib import import_module from django.utils.module_loading import module_has_submodule for app in ADMIN_INNER_APPS: mod = import_module(app) # Attempt to import the app's admin module. try: before_import_registry = copy.copy(admin.site._registry) import_module('%s.admin' % app) except: # Reset the model registry to the state before the last import as # this import will have to reoccur on the next request and this # could raise NotRegistered and AlreadyRegistered exceptions # (see #8245). admin.site._registry = before_import_registry # Decide whether to bubble up this error. If the app just # doesn't have an admin module, we can ignore the error # attempting to import it, otherwise we want it to bubble up. if module_has_submodule(mod, 'admin'): raise
def test_loader(self): "Normal module existence can be tested" test_module = import_module('regressiontests.utils.test_module') # An importable child self.failUnless(module_has_submodule(test_module, 'good_module')) mod = import_module('regressiontests.utils.test_module.good_module') self.assertEqual(mod.content, 'Good Module') # A child that exists, but will generate an import error if loaded self.failUnless(module_has_submodule(test_module, 'bad_module')) self.assertRaises(ImportError, import_module, 'regressiontests.utils.test_module.bad_module') # A child that doesn't exist self.failIf(module_has_submodule(test_module, 'no_such_module')) self.assertRaises(ImportError, import_module, 'regressiontests.utils.test_module.no_such_module')
def autodiscover(): """ Auto-discover INSTALLED_APPS admin.py modules and fail silently when not present. This forces an import on them to register any admin bits they may want. """ import copy from django.conf import settings from django.utils.importlib import import_module from django.utils.module_loading import module_has_submodule for app in settings.INSTALLED_APPS: mod = import_module(app) # Attempt to import the app's admin module. try: before_import_registry = copy.copy(site._registry) import_module('%s.admin' % app) except: # Reset the model registry to the state before the last import as # this import will have to reoccur on the next request and this # could raise NotRegistered and AlreadyRegistered exceptions # (see #8245). site._registry = before_import_registry # Decide whether to bubble up this error. If the app just # doesn't have an admin module, we can ignore the error # attempting to import it, otherwise we want it to bubble up. if module_has_submodule(mod, 'admin'): raise
def load_app(self, app_name, can_postpone=True): """ 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: router = import_module(".routers", app_name) except ImportError: self.nesting_level -= 1 if not module_has_submodule(app_module, "routers"): return None else: if can_postpone: self.postponed.append(app_name) return None else: raise self.nesting_level -= 1 if router not in self.app_store: self.app_store[router] = len(self.app_store) self.app_labels[self._label_for(router)] = router return router
def initialize(): logger.info("Initializing Kermit WebUI environment") """ Auto-discover INSTALLED_APPS with MODULES_TO_IMPORT modules. """ for app in settings.INSTALLED_APPS: mod = import_module(app) if hasattr(mod, "initialize"): try: mod.initialize() except: logger.error("ERROR initializing module %s! %s" % (app, sys.exc_info)) else: logger.debug("App %s does not have initialization method" % app) for current_module in MODULES_TO_IMPORT: try: before_import_registry = copy.copy(kermit_modules._registry) import_module("%s.%s" % (app, current_module)) except: kermit_modules._registry = before_import_registry if module_has_submodule(mod, current_module): logger.error("Module %s found but there is an error importing it") logger.error(sys.exc_info()) continue
def autodiscover(module_name=None): """ Auto-discover INSTALLED_APPS permissions.py modules and fail silently when not present. This forces an import on them to register any permissions bits they may want. """ import copy from django.conf import settings from django.utils.importlib import import_module from django.utils.module_loading import module_has_submodule from permission.handlers import registry module_name = module_name or settings.PERMISSION_MODULE_NAME for app in settings.INSTALLED_APPS: mod = import_module(app) # Attempt to import the app's permissions module try: before_import_registry = copy.copy(registry._registry) import_module('%s.%s' % (app, module_name)) except: # Reset the model registry to the state before tha last import as # this import will have to reoccur on the next request and this # could raise NotRegistered and AlreadyRegistered exceptions # (see #8254) registry._registry = before_import_registry # Decide whether to bubble up this error. If the app just # doesn't have an permissions module, we can ignore the error # attempting to import it, otherwise we want it to bubble up. if module_has_submodule(mod, module_name): raise
def ready(self): # if ready was already called if hasattr(self, 'bmf_config'): # pragma: no cover return True self.bmf_config = apps.get_app_config(self.bmf_label) if not hasattr(self.bmf_config, 'site'): # pragma: no cover raise ImproperlyConfigured( "Can not find a site attribute in %(cls)s. " "Please import the BMF-Framework before you " "import any BMF-Modules in your INSTALLED_APPS." % { 'cls': self.bmf_config.__class__.__name__ } ) # autodiscover bmf modules ============================================ if module_has_submodule(self.module, "bmf_module"): # pragma: no branch # load instructions of bmf_module.py import_module('%s.%s' % (self.name, "bmf_module")) # see if model needs a number_cycle for model in [m for m in self.models.values() if hasattr(m, '_bmfmeta') and m._bmfmeta.number_cycle]: self.bmf_config.site.register_numbercycle(model) logger.debug('App "%s" (%s) is ready' % ( self.verbose_name, self.label, ))
def autodiscover(): """ Auto-discover INSTALLED_APPS mockup.py modules and fail silently when not present. This forces an import on them to register any mockup bits they may want. """ global _registry for app in settings.INSTALLED_APPS: mod = import_module(app) # Attempt to import the app's mockup module. try: before_import_registry = copy.copy(_registry) import_module('%s.mockup' % app) except: # Reset the model registry to the state before the last import as # this import will have to reoccur on the next request and this # could raise NotRegistered and AlreadyRegistered exceptions # (see #8245). _registry = before_import_registry # Decide whether to bubble up this error. If the app just # doesn't have an mockup module, we can ignore the error # attempting to import it, otherwise we want it to bubble up. if module_has_submodule(mod, 'mockup'): raise
def collect_indexes(self): indexes = [] for app in settings.INSTALLED_APPS: mod = importlib.import_module(app) try: search_index_module = importlib.import_module("%s.search_indexes" % app) except ImportError: if module_has_submodule(mod, "search_indexes"): raise continue for item_name, item in inspect.getmembers(search_index_module, inspect.isclass): if getattr(item, "haystack_use_for_indexing", False) and getattr(item, "get_model", None): # We've got an index. Check if we should be ignoring it. class_path = "%s.search_indexes.%s" % (app, item_name) if class_path in self.excluded_indexes or self.excluded_indexes_ids.get(item_name) == id(item): self.excluded_indexes_ids[str(item_name)] = id(item) continue indexes.append(item()) return indexes
def collect_indexes(self): indexes = [] for app in settings.INSTALLED_APPS: try: mod = importlib.import_module(app) except ImportError: warnings.warn('Installed app %s is not an importable Python module and will be ignored' % app) continue try: search_index_module = importlib.import_module("%s.search_indexes" % app) except ImportError: if module_has_submodule(mod, 'search_indexes'): raise continue for item_name, item in inspect.getmembers(search_index_module, inspect.isclass): if getattr(item, 'haystack_use_for_indexing', False) and getattr(item, 'get_model', None): # We've got an index. Check if we should be ignoring it. class_path = "%s.search_indexes.%s" % (app, item_name) if class_path in self.excluded_indexes or self.excluded_indexes_ids.get(item_name) == id(item): self.excluded_indexes_ids[str(item_name)] = id(item) continue indexes.append(item()) return indexes
def initialize(): logger.info("Initializing Plugins environment") """ Auto-discover INSTALLED_MODULES with MODULES_TO_IMPORT modules. """ installed_plugins = utils.installed_plugins_list() logger.info("Installed Plugins: %s" % installed_plugins) for plugin in installed_plugins: mod = import_module("%s.%s" % (BASE_PLUGIN_PATH, plugin)) for current_module in MODULES_TO_IMPORT: try: before_import_registry = copy.copy(plugins._registry) import_module('%s.%s.%s' % (BASE_PLUGIN_PATH, plugin, current_module)) except: plugins._registry = before_import_registry if module_has_submodule(mod, current_module): logger.error("Module %s found but there is an error importing it") logger.error(sys.exc_info()) continue if CHECK_WIDGETS: try: imp.find_module("widgets", mod.__path__) registry.inject_widget("%s.%s" % (BASE_PLUGIN_PATH, plugin)) except ImportError: logger.debug ("Plugin %s does not provides widgets" % plugin)
def setUpClass(cls): super(TestModelsLoaderMixin, cls).setUpClass() cls._tests_loader_models_mod = None if not cls.tests_app: cls.tests_app = cls.__module__ tests_module = import_module(cls.tests_app) if not module_has_submodule(tests_module, 'models'): # Set up a 'models' module, containing any models local to the # module that this TestCase is in. models_mod_name = '%s.models' % cls.tests_app models_mod = imp.new_module(models_mod_name) # Django needs a value here. Doesn't matter what it is. models_mod.__file__ = '' # Transfer all the models over into this new module. test_module = sys.modules[cls.__module__] for key, value in six.iteritems(test_module.__dict__): if inspect.isclass(value) and issubclass(value, Model): models_mod.__dict__[key] = value cls._tests_loader_models_mod = models_mod
def autodiscover(glean_noun='gleaners'): """Like admin's autodiscover. gleaners is the name of the module containing connectors. """ import copy from django.conf import settings from django.utils.importlib import import_module from django.utils.module_loading import module_has_submodule for app in settings.INSTALLED_APPS: mod = import_module(app) # Attempt to import the app's gleaners module. try: before_import_register = copy.copy(registry._register) registry.register(app, glean_noun) except Exception, e: print e log.error(e) registry._register = before_import_register # Decide whether to bubble up this error. If the app just # doesn't have a gleaners module, we can ignore the error # attempting to import it, otherwise we want it to bubble up. if module_has_submodule(mod, glean_noun): raise e
def autodiscover(): """ Autodiscover function from django.contrib.admin """ for app in settings.INSTALLED_APPS: mod = import_module(app) try: before_import_registry = copy.copy(site._registry) import_module('%s.admin' % app) except: site._registry = before_import_registry if module_has_submodule(mod, 'admin'): raise
def collect_consts(): consts_dict = {} for app in apps.get_app_configs(): if not module_has_submodule(app.module, 'consts'): continue consts = get_consts(import_module('%s.consts' % app.name)) if not consts: continue consts_dict[app.label] = consts return consts_dict
def import_modelresources(self): """ If a plugin has a modelresource.py, import it (This exists when a plugin knows how to import-export itself) """ if ( module_has_submodule(self.module, MODELRESOURCE_MODULE_NAME) and self.name != "pulpcore.app" ): modelrsrc_module_name = "{name}.{module}".format( name=self.name, module=MODELRESOURCE_MODULE_NAME ) self.modelresource_module = import_module(modelrsrc_module_name) self.exportable_classes = self.modelresource_module.IMPORT_ORDER
def import_app_sitetree_module(app): """Imports sitetree module from a given app. :param str|unicode app: Application name :return: module|None """ module_name = settings.APP_MODULE_NAME module = import_module(app) try: sub_module = import_module('%s.%s' % (app, module_name)) return sub_module except ImportError: if module_has_submodule(module, module_name): raise return None
def _return_module(self, module_name): if module_has_submodule(sys.modules[self.module_path], module_name): models_module_name = "%s.%s" % (self.module_path, module_name) try: return import_module(models_module_name) except Exception as e: logging.warn( "Tried to import module {module_name} from {plugin} but an error was raised" .format( plugin=self.module_path, module_name=module_name, )) logging.exception(e) return None
def autodiscover(): REPORTING_SOURCE_FILE = getattr(settings, 'REPORTING_SOURCE_FILE', 'reports') modules = [] for app in settings.INSTALLED_APPS: mod = import_module(app) try: module = import_module('%s.%s' % (app, REPORTING_SOURCE_FILE)) except: if module_has_submodule(mod, REPORTING_SOURCE_FILE): raise else: modules.append(module) return modules
def is_library_missing(name): """Check if library that failed to load cannot be found under any templatetags directory or does exist but fails to import. Non-existing condition is checked recursively for each subpackage in cases like <appdir>/templatetags/subpackage/package/module.py. """ # Don't bother to check if '.' is in name since any name will be prefixed # with some template root. path, module = name.rsplit('.', 1) try: package = import_module(path) return not module_has_submodule(package, module) except ImportError: return is_library_missing(path)
def discover_gooddata_modules(): gd_classes = {} for app in settings.INSTALLED_APPS: mod = import_module(app) try: gd_module = import_module('%s.gooddata' % app) for (cls_name, cls) in inspect.getmembers(gd_module, inspect.isclass): if not issubclass(cls, Dataset): continue app_cls_name = '.'.join((app.split('.')[-1], cls_name)) gd_classes[app_cls_name] = cls except: if module_has_submodule(mod, 'gooddata'): raise return gd_classes
def import_models(self): # Dictionary of models for this app, primarily maintained in the # 'all_models' attribute of the Apps this AppConfig is attached to. # 由于apps.all_models是DefaultDict类型,当访问该字典中不存在的Key时,其将自动创建一个空键值 # 因此,当访问self.apps.all_models[self.label]时,如果不存在,则自动创建一个空的字典项 # 并将该字典项赋值给self.models属性 self.models = self.apps.all_models[self.label] # Model模块的名称必须是'Models' if module_has_submodule(self.module, MODELS_MODULE_NAME): models_module_name = '%s.%s' % (self.name, MODELS_MODULE_NAME) # 导入Model模块后,创建Model类时(注意不是实例),会调用元类django.db.base.ModelBase.__new__()方法 # 在该方法中,会调用apps.register_model()方法,完成对apps.all_models属性的赋值 self.models_module = import_module(models_module_name)
def test_loader(self): "Normal module existence can be tested" test_module = import_module('regressiontests.utils.test_module') # An importable child self.assertTrue(module_has_submodule(test_module, 'good_module')) mod = import_module('regressiontests.utils.test_module.good_module') self.assertEqual(mod.content, 'Good Module') # A child that exists, but will generate an import error if loaded self.assertTrue(module_has_submodule(test_module, 'bad_module')) self.assertRaises(ImportError, import_module, 'regressiontests.utils.test_module.bad_module') # A child that doesn't exist self.assertFalse(module_has_submodule(test_module, 'no_such_module')) self.assertRaises(ImportError, import_module, 'regressiontests.utils.test_module.no_such_module') # Don't be confused by caching of import misses import types # causes attempted import of regressiontests.utils.types self.assertFalse( module_has_submodule(sys.modules['regressiontests.utils'], 'types'))
def discover_tasks_modules(self): ignored_modules = set(getattr(settings, "DRAMATIQ_IGNORED_MODULES", [])) app_configs = (c for c in apps.get_app_configs() if module_has_submodule(c.module, "tasks")) tasks_modules = ["django_periodiq.setup"] # Broker module is first for conf in app_configs: module = conf.name + ".tasks" if module in ignored_modules: self.stdout.write(" * Ignored tasks module: %r" % module) else: self.stdout.write(" * Discovered tasks module: %r" % module) tasks_modules.append(module) return tasks_modules
def _autodiscover(recipes): import copy from django.conf import settings from django.utils.importlib import import_module from django.utils.module_loading import module_has_submodule for app in settings.INSTALLED_APPS: mod = import_module(app) try: before_import_recipes = copy.copy(recipes) import_module('%s.badgify_recipes' % app) except: recipes = before_import_recipes if module_has_submodule(mod, 'badgify_recipes'): raise
def handle(self, *args, **options): print("Commencing dev data import", file=stdout) for app in settings.INSTALLED_APPS: mod = import_module(app) # Attempt to import the app's test.data module. try: mod_data = import_module('%s.tests.data' % app) mod_data.load() except: # Decide whether to bubble up this error. If the app just # doesn't have an test.data module, we can ignore the error # attempting to import it, otherwise we want it to bubble up. if module_has_submodule(mod, 'test.data'): raise
def autodiscover(*args): ''' Discover submodules in Django apps that would otherwise be ignored (listeners, configforms, etc) Usage: autodiscover('configforms'[, 'listeners'[, ...]]) ''' from django.conf import settings from django.utils.importlib import import_module from django.utils.module_loading import module_has_submodule for submod in args: for app in settings.INSTALLED_APPS: mod = import_module(app) if module_has_submodule(mod, submod): import_module('%s.%s' % (app, submod))
def autodiscover(site): import copy from django.conf import settings from django.utils.importlib import import_module from django.utils.module_loading import module_has_submodule for app in settings.INSTALLED_APPS: mod = import_module(app) try: before_import_registry = copy.copy(site._registry) import_module('%s.admin' % app) except: site._registry = before_import_registry if module_has_submodule(mod, 'admin'): raise
def autodiscover(): """ Auto-discover INSTALLED_APPS badges.py modules and fail silently when not present. """ from django.utils.importlib import import_module for app in django_settings.INSTALLED_APPS: mod = import_module(app) try: badges_mod = import_module('%s.badges' % app) if hasattr(badges_mod, 'register_signals'): badges_mod.register_signals() except ImportError: if module_has_submodule(mod, 'badges'): raise
def autodiscover(): ''' Auto-discover INSTALLED_APPS translation.py modules and fail silently when not present. This forces an import on them to register. Also import explicit modules. ''' import os import sys import copy from django.utils.module_loading import module_has_submodule from modeltrans.translator import translator from importlib import import_module from django.conf import settings from django.apps import apps mods = [(app_config.name, app_config.module) for app_config in apps.get_app_configs()] for (app, mod) in mods: # Attempt to import the app's translation module. module = '%s.translation' % app before_import_registry = copy.copy(translator._registry) try: import_module(module) except: # Reset the model registry to the state before the last import as # this import will have to reoccur on the next request and this # could raise NotRegistered and AlreadyRegistered exceptions translator._registry = before_import_registry # Decide whether to bubble up this error. If the app just # doesn't have an translation module, we can ignore the error # attempting to import it, otherwise we want it to bubble up. if module_has_submodule(mod, 'translation'): raise # In debug mode, print a list of registered models and pid to stdout. # Note: Differing model order is fine, we don't rely on a particular # order, as far as base classes are registered before subclasses. if settings.DEBUG: try: if sys.argv[1] in ('runserver', 'runserver_plus'): models = translator.get_registered_models() names = ', '.join(m.__name__ for m in models) print('modeltrans: Registered %d models for translation' ' (%s) [pid: %d].' % (len(models), names, os.getpid())) except IndexError: pass
def _autodiscover(self): """Discovers panels to register from the current dashboard module.""" if getattr(self, "_autodiscover_complete", False): return panels_to_discover = [] panel_groups = [] # If we have a flat iterable of panel names, wrap it again so # we have a consistent structure for the next step. if all([isinstance(i, six.string_types) for i in self.panels]): self.panels = [self.panels] # Now iterate our panel sets. default_created = False for panel_set in self.panels: # Instantiate PanelGroup classes. if not isinstance(panel_set, collections.Iterable) and \ issubclass(panel_set, PanelGroup): panel_group = panel_set(self) # Check for nested tuples, and convert them to PanelGroups elif not isinstance(panel_set, PanelGroup): panel_group = PanelGroup(self, panels=panel_set) # Put our results into their appropriate places panels_to_discover.extend(panel_group.panels) panel_groups.append((panel_group.slug, panel_group)) if panel_group.slug == DEFAULT_PANEL_GROUP: default_created = True # Plugin panels can be added to a default panel group. Make sure such a # default group exists. if not default_created: default_group = PanelGroup(self) panel_groups.insert(0, (default_group.slug, default_group)) self._panel_groups = collections.OrderedDict(panel_groups) # Do the actual discovery package = '.'.join(self.__module__.split('.')[:-1]) mod = import_module(package) for panel in panels_to_discover: try: before_import_registry = copy.copy(self._registry) import_module('.%s.panel' % panel, package) except Exception: self._registry = before_import_registry if module_has_submodule(mod, panel): raise self._autodiscover_complete = True
def handle(self, fixture, **options): available_fixtures = {} for app in settings.INSTALLED_APPS: try: fixture_gen = import_module(".fixture_gen", app) except ImportError: if module_has_submodule(import_module(app), "fixture_gen"): raise continue for obj in fixture_gen.__dict__.values(): if getattr(obj, "__fixture_gen__", False): available_fixtures[(app.rsplit(".", 1)[-1], obj.__name__)] = obj app_label, fixture_name = fixture.rsplit(".", 1) try: fixture = available_fixtures[(app_label, fixture_name)] except KeyError: available = ", ".join( "%s.%s" % (app_label, fixture_name) for app_label, fixture_name in available_fixtures ) raise CommandError("Fixture generator '%s' not found, available " "choices: %s" % (fixture, available)) requirements, models = linearize_requirements(available_fixtures, fixture) settings.DATABASES[FIXTURE_DATABASE] = { "ENGINE": "django.db.backends.sqlite3", "NAME": ":memory:", } old_routers = router.routers router.routers = [FixtureRouter(models)] try: # migrate_all=True is for south, Django just absorbs it call_command("syncdb", database=FIXTURE_DATABASE, verbosity=0, interactive=False, migrate_all=True) for fixture_func in requirements: fixture_func() call_command("dumpdata", *["%s.%s" % (m._meta.app_label, m._meta.object_name) for m in models], **dict(options, verbosity=0, database=FIXTURE_DATABASE) ) finally: del settings.DATABASES[FIXTURE_DATABASE] if isinstance(connections._connections, dict): del connections._connections[FIXTURE_DATABASE] else: delattr(connections._connections, FIXTURE_DATABASE) router.routers = old_routers
def collect_indexes_with_debugging(original_function, self): from django.conf import settings print "collect_indexes: settings = %s" % settings print "collect_indexes: INSTALLED_APPS = %s" % settings.INSTALLED_APPS # import pdb; pdb.set_trace() from haystack import connections from django.utils.module_loading import module_has_submodule import inspect try: from django.utils import importlib except ImportError: from haystack.utils import importlib for app in settings.INSTALLED_APPS: print "collect_indexes: trying %s" % app mod = importlib.import_module(app) try: search_index_module = importlib.import_module("%s.search_indexes" % app) except ImportError: if module_has_submodule(mod, 'search_indexes'): raise continue for item_name, item in inspect.getmembers(search_index_module, inspect.isclass): print "collect_indexes: %s: %s" % ( item_name, getattr(item, 'haystack_use_for_indexing', False)) if getattr(item, 'haystack_use_for_indexing', False): # We've got an index. Check if we should be ignoring it. class_path = "%s.search_indexes.%s" % (app, item_name) print "excluded_index %s = %s" % (class_path, class_path in self.excluded_indexes) print "excluded_indexes_id %s = %s" % ( str(item_name), self.excluded_indexes_ids.get(item_name) == id(item)) if class_path in self.excluded_indexes or self.excluded_indexes_ids.get( item_name) == id(item): self.excluded_indexes_ids[str(item_name)] = id(item) continue return original_function(self)
def get_callable(lookup_view, can_fail=False): """ 将函数的字符串版本转换成一个可调用的函数, 主要是从各个 app 中搜索相关的 view Convert a string version of a function name to the callable object. If the lookup_view is not an import path, it is assumed to be a URL pattern label and the original string is returned. If can_fail is True, lookup_view might be a URL pattern label, so errors during the import fail and the string is returned. """ if not callable(lookup_view): mod_name, func_name = get_mod_func(lookup_view) if func_name == '': return lookup_view try: mod = import_module(mod_name) 尝试导入 except ImportError: parentmod, submod = get_mod_func(mod_name) if (not can_fail and submod != '' and not module_has_submodule(import_module(parentmod), submod)): raise ViewDoesNotExist( "Could not import %s. Parent module %s does not exist." % (lookup_view, mod_name)) if not can_fail: raise else: try: lookup_view = getattr(mod, func_name) # 异常 if not callable(lookup_view): raise ViewDoesNotExist( "Could not import %s.%s. View is not callable." % (mod_name, func_name)) except AttributeError: if not can_fail: raise ViewDoesNotExist( "Could not import %s. View does not exist in module %s." % (lookup_view, mod_name)) return lookup_view
def import_models(self): # Dictionary of models for this app, primarily maintained in the # 'all_models' attribute of the Apps this AppConfig is attached to. # # 这里是一个shadow-copy, # 即: self.apps.all_models 发生变化后, self.models 也会跟着发生变化. self.models = self.apps.all_models[self.label] if module_has_submodule(self.module, MODELS_MODULE_NAME): models_module_name = '%s.%s' % (self.name, MODELS_MODULE_NAME) # 这里负责导入model, # ModelBase会回调register.register_model, # 将 model 写入回到 self.apps.all_modles 中, # 从而更新到 self.models 中. self.models_module = import_module(models_module_name)
def _get_default_urlpatterns(self): package_string = '.'.join(self.__module__.split('.')[:-1]) if getattr(self, 'urls', None): try: mod = import_module('.%s' % self.urls, package_string) except ImportError: mod = import_module(self.urls) urlpatterns = mod.urlpatterns else: # Try importing a urls.py from the dashboard package if module_has_submodule(import_module(package_string), 'urls'): urls_mod = import_module('.urls', package_string) urlpatterns = urls_mod.urlpatterns else: urlpatterns = [] return urlpatterns
def autodiscover(): """ Taken from ``django.contrib.admin.autodiscover`` and used to run any calls to the ``processor_for`` decorator. """ global LOADED if LOADED: return LOADED = True for app in settings.INSTALLED_APPS: module = import_module(app) try: import_module("%s.page_processors" % app) except: if module_has_submodule(module, "page_processors"): raise
def import_models(self, all_models=None): if all_models == None: self.models = self.apps.all_models[self.label] else: self.models = all_models if module_has_submodule(self.module, MODELS_MODULE_NAME): for _mod in self.models: mod = self.models[_mod] # if type(mod) != str and mod._meta.app_label == self.name: # return models_module_name = "%s.%s" % (self.name, MODELS_MODULE_NAME) try: self.models_module = import_module(models_module_name) except: self.models_module = None
def load_caches(): import_module('.caches', 'flash') FLASH_APPS = flash_settings.FLASH_APPS if isfunction(FLASH_APPS): FLASH_APPS = FLASH_APPS() for app_name in FLASH_APPS: app_module = import_module(app_name) try: module = import_module('.caches', app_name) except ImportError: if module_has_submodule(app_module, 'caches'): print('Import error in %s/caches.py:' % app_name) raise import flash.contenttypes_caches
def update_badges(overwrite=False): from django.utils.importlib import import_module for app in settings.INSTALLED_APPS: mod = import_module(app) try: badges_mod = import_module('%s.badges' % app) fixture_label = '%s_badges' % app.replace('.', '_') call_command('loaddata', fixture_label, verbosity=1) if hasattr(badges_mod, 'badges'): badger.utils.update_badges(badges_mod.badges, overwrite) if hasattr(badges_mod, 'update_badges'): badges_mod.update_badges(overwrite) except ImportError: if module_has_submodule(mod, 'badges'): raise
def discover_tasks_modules(self): ignored_modules = set(getattr(settings, "DRAMATIQ_IGNORED_MODULES", [])) app_configs = (c for c in apps.get_app_configs() if module_has_submodule(c.module, "tasks")) tasks_modules = ["django_dramatiq.setup"] def is_ignored_module(module_name): if not ignored_modules: return False if module_name in ignored_modules: return True name_parts = module_name.split(".") for c in range(1, len(name_parts)): part_name = ".".join(name_parts[:c]) + ".*" if part_name in ignored_modules: return True return False for conf in app_configs: module = conf.name + ".tasks" if is_ignored_module(module): self.stdout.write(" * Ignored tasks module: %r" % module) continue imported_module = importlib.import_module(module) if not self._is_package(imported_module): self.stdout.write(" * Discovered tasks module: %r" % module) tasks_modules.append(module) else: submodules = self._get_submodules(imported_module) for submodule in submodules: if is_ignored_module(submodule): self.stdout.write(" * Ignored tasks module: %r" % submodule) else: self.stdout.write(" * Discovered tasks module: %r" % submodule) tasks_modules.append(submodule) return tasks_modules
def autodiscover(): # 为 crispy_form 动态设置的settings项 setattr(settings, 'CRISPY_TEMPLATE_PACK', 'bootstrap3') setattr( settings, 'CRISPY_CLASS_CONVERTERS', { "textinput": "textinput textInput form-control", "fileinput": "fileinput fileUpload form-control", "passwordinput": "textinput textInput form-control", }) # 加载内置相关视图 register_builtin_views(site) # 加载插件 register_builtin_plugins(site) # 加载各app的 adminx for app in settings.INSTALLED_APPS: # 加载app mod = import_module(app) app_label = app.split('.')[-1] site.app_dict[app_label] = mod # app级菜单初始化 site.sys_menu[app_label] = { '_default_group': { 'title': u'其他', 'icon': 'group_configure', 'menus': [] } } if hasattr(mod, 'menus'): m_menus = mod.menus for e in m_menus: site.sys_menu[app_label][e[0]] = { 'title': e[1], 'icon': e[2], 'menus': [] } # 导入 adminx 模块 try: before_import_registry = site.copy_registry() import_module('%s.adminx' % app) except: site.restore_registry(before_import_registry) if module_has_submodule(mod, 'adminx'): raise
def autodiscover(): from importlib import import_module from django.conf import settings from django.utils.module_loading import module_has_submodule for app in settings.INSTALLED_APPS: mod = import_module(app) # Attempt to import the app's api module. try: import_module('%s.publishers' % app) except: # Decide whether to bubble up this error. If the app just # doesn't have an admin module, we can ignore the error # attempting to import it, otherwise we want it to bubble up. if module_has_submodule(mod, 'publishers'): raise