Loads all the backends setup in settings.py.
334272
def load_backends(self):
    
    for name, backend_settings in settings.storage.iteritems():
      backend_path = backend_settings['backend']
      backend_module, backend_cls = backend_path.rsplit('.', 1)
      backend_module = import_module(backend_module)
      # Create an instance of the configured backend.
      backend_constructor = getattr(backend_module, backend_cls)
      self.backends[name] = backend_constructor(name,
                                                self.namespaces,
                                                **backend_settings)
392362
def setup(
            self):
        

        return self.arguments, self.settings, self.log, self.dbConn
586647
def load(self):
        
        data = self.dict_class()
        
        for path in self.paths:
            if path in self.paths_loaded: continue
            
            try:
                with open(path, 'r') as file:
                    path_data = yaml.load(file.read())
                    data = dict_merge(data, path_data)
                self.paths_loaded.add(path)
            except IOError:
                # TODO: Log this correctly once logging is implemented
                if not path.endswith('.local.yml'):
                    print 'CONFIG NOT FOUND: %s' % (path)

        self.data = data
806806
public function loadSettings()
    {
        $extra                = $this->composer->getPackage()->getExtra();
        $config               = static::mergeConfig($extra);
        $this->includes       = is_array($config['include']) ? $config['include'] : [$config['include']];
        $this->requires       = is_array($config['require']) ? $config['require'] : [$config['require']];
        $this->recurse        = (bool) $config['recurse'];
        $this->replace        = (bool) $config['replace'];
        $this->ignore         = (bool) $config['ignore-duplicates'];
        $this->mergeDev       = (bool) $config['merge-dev'];
        $this->mergeExtra     = (bool) $config['merge-extra'];
        $this->mergeExtraDeep = (bool) $config['merge-extra-deep'];
        $this->mergeScripts   = (bool) $config['merge-scripts'];
    }
200882
def configure_settings(settings, environment_settings=True):
    '''
    
    '''
    changes = 1
    iterations = 0

    while changes:
        changes = 0
        app_names = ['django_autoconfig'] + list(settings['INSTALLED_APPS'])
        if environment_settings:
            app_names.append('django_autoconfig.environment_settings')
        for app_name in app_names:
            import django_autoconfig.contrib
            if autoconfig_module_exists(app_name):
                module = importlib.import_module("%s.autoconfig" % (app_name,))
            elif app_name in django_autoconfig.contrib.CONTRIB_CONFIGS:
                module = django_autoconfig.contrib.CONTRIB_CONFIGS[app_name]
            else:
                continue
            changes += merge_dictionaries(
                settings,
                getattr(module, 'SETTINGS', {}),
                template_special_case=True,
            )
            changes += merge_dictionaries(
                settings,
                getattr(module, 'DEFAULT_SETTINGS', {}),
                only_defaults=True,
            )
            for relationship in getattr(module, 'RELATIONSHIPS', []):
                changes += relationship.apply_changes(settings)

        if iterations >= MAX_ITERATIONS:
            raise ImproperlyConfigured(
                'Autoconfiguration could not reach a consistent state'
            )
        iterations += 1
    LOGGER.debug("Autoconfiguration took %d iterations.", iterations)
566879
def load_config(self, settings=None):
        
        self._load_defaults()
        if settings:
            self.update(settings)
        else:
            config_paths = _get_config_files()
            for p in config_paths:
                conf = _process_config_file([p])
                self.update(conf)
        self._loaded = True
        self._validate()
1198782
public function loadConfig() {
        $this->allLocales = config('app.all_locales');
        $this->defaultLocales = config('app.fallback_locale');
        $this->usePrefixForDefault = config('routelocale.default_prefix');
    }
1041510
def import_backend(config):
    
    backend_name = config['backend']
    path = backend_name.split('.')
    backend_mod_name, backend_class_name = '.'.join(path[:-1]), path[-1]
    backend_mod = importlib.import_module(backend_mod_name)
    backend_class = getattr(backend_mod, backend_class_name)
    return backend_class(config['settings'])
574623
def load(self):
        
        s = load_stack(self)
        if s:
            self.hooks = s.hooks
            self.calls = s.calls
1293465
def load():
    
    config = ConfigParser.RawConfigParser(DEFAULTS)
    config.readfp(open(CONF_PATH))
    for section in config.sections():
        globals()[section] = {}
        for key, val in config.items(section):
            globals()[section][key] = val
865143
private function LoadBackendTranslations()
    {
        $backendUser = BackendModule::Guard()->GetUser();
        if ($backendUser)
        {
            $backendLanguage = $backendUser->GetLanguage()->GetCode();
            $backendTranslations = PathUtil::BackendBundleTranslationFile($this->BundleName(), $backendLanguage);
            if (File::Exists($backendTranslations))
            {
                require_once $backendTranslations;
            }
        }
    }
933261
def load_configuration(settings)
      configuration = settings.with_indifferent_access
      self.options = configuration[:options]
      self.clients = configuration[:clients]
      set_log_levels
    end
1274570
def load_modules(self):
        """"""
        if self.INTERFACES_MODULE is None:
            raise NotImplementedError("A module containing interfaces modules "
                                      "should be setup in INTERFACES_MODULE !")
        else:
            for module, permission in self.modules.items():
                i = getattr(self.INTERFACES_MODULE,
                            module).Interface(self, permission)
                self.interfaces[module] = i
1209885
def bind_settings():
    
    from django_productline import settings

    if settings.TEMPLATE_LOADER_CACHED_ENABLED:
        loaders = [
            ['django.template.loaders.cached.Loader', settings.DJANGO_TEMPLATE_LOADERS]
        ]
    else:
        loaders = settings.DJANGO_TEMPLATE_LOADERS

    if compare_version(django.get_version(), '1.9') >= 0:

        TEMPLATES = [
            {
                'BACKEND': settings.DJANGO_TEMPLATE_BACKEND,
                'DIRS': settings.DJANGO_TEMPLATE_DIRS,
                'OPTIONS': {
                    'builtins': settings.DJANGO_TEMPLATE_BUILTINS,
                    'context_processors': settings.DJANGO_TEMPLATE_CONTEXT_PROCESSORS,
                    'loaders': loaders,
                    'debug': settings.DJANGO_TEMPLATE_DEBUG
                },
            },
        ]

        setattr(settings, 'TEMPLATES', TEMPLATES)

    else:
        setattr(settings, 'TEMPLATE_DEBUG', settings.DJANGO_TEMPLATE_DEBUG)
        setattr(settings, 'TEMPLATE_DIRS', settings.DJANGO_TEMPLATE_DIRS)
        setattr(settings, 'TEMPLATE_CONTEXT_PROCESSORS', settings.DJANGO_TEMPLATE_CONTEXT_PROCESSORS)
        setattr(settings, 'TEMPLATE_LOADERS', loaders)
1333588
def setup(self, app):
        """"""
        super().setup(app)

        self.enabled = len(self.cfg.backends)

        self.default = self.cfg.default
        if not self.default and self.enabled:
            self.default = self.cfg.backends[0][0]

        self.backends_hash = {name: parse.urlparse(loc) for (name, loc) in self.cfg.backends}
        if self.default and self.default not in self.backends_hash:
            raise PluginException('Backend not found: %s' % self.default)
921161
def load(self, local='localsettings.py', default='settings.py'):
        '''
        
        '''
        self._load_defaults(default)
        self._load_custom(local)

        return self.settings()
472716
def load_all_plugins(self):
        """"""

        # Go through the existing python files in the plugin directory
        self.plugin_path = os.path.realpath(self.plugin_dir)
        sys.path.append(self.plugin_dir)
        print '<<< Plugin Manager >>>'
        for f in [os.path.join(self.plugin_dir, child) for child in os.listdir(self.plugin_dir)]:

            # Skip certain files
            if '.DS_Store' in f or '__init__.py' in f: 
                continue

            # Add the plugin
            self.add_plugin(f)