Initialize MacroResolver instance with conf.
        Must be called at least once.

        :param conf: configuration to load
        :type conf: alignak.objects.Config
        :return: None
320714
def init(self, conf):
        

        # For searching class and elements for on-demand
        # we need link to types
        self.my_conf = conf
        self.lists_on_demand = []
        self.hosts = self.my_conf.hosts
        # For special void host_name handling...
        self.host_class = self.hosts.inner_class
        self.lists_on_demand.append(self.hosts)
        self.services = self.my_conf.services
        self.contacts = self.my_conf.contacts
        self.lists_on_demand.append(self.contacts)
        self.hostgroups = self.my_conf.hostgroups
        self.lists_on_demand.append(self.hostgroups)
        self.commands = self.my_conf.commands
        self.servicegroups = self.my_conf.servicegroups
        self.lists_on_demand.append(self.servicegroups)
        self.contactgroups = self.my_conf.contactgroups
        self.lists_on_demand.append(self.contactgroups)
        self.illegal_macro_output_chars = self.my_conf.illegal_macro_output_chars
        self.env_prefix = self.my_conf.env_variables_prefix
1215651
def init_config(args):
    
    os.environ["AUTOMLBOARD_LOGDIR"] = args.logdir
    os.environ["AUTOMLBOARD_LOGLEVEL"] = args.log_level
    os.environ["AUTOMLBOARD_RELOAD_INTERVAL"] = str(args.reload_interval)

    if args.db:
        try:
            db_address_reg = re.compile(r"(.*)://(.*):(.*)@(.*):(.*)/(.*)")
            match = re.match(db_address_reg, args.db_address)
            os.environ["AUTOMLBOARD_DB_ENGINE"] = match.group(1)
            os.environ["AUTOMLBOARD_DB_USER"] = match.group(2)
            os.environ["AUTOMLBOARD_DB_PASSWORD"] = match.group(3)
            os.environ["AUTOMLBOARD_DB_HOST"] = match.group(4)
            os.environ["AUTOMLBOARD_DB_PORT"] = match.group(5)
            os.environ["AUTOMLBOARD_DB_NAME"] = match.group(6)
            logger.info("Using %s as the database backend." % match.group(1))
        except BaseException as e:
            raise DatabaseError(e)
    else:
        logger.info("Using sqlite3 as the database backend, "
                    "information will be stored in automlboard.db")

    os.environ.setdefault("DJANGO_SETTINGS_MODULE",
                          "ray.tune.automlboard.settings")
    django.setup()
    command = [os.path.join(root_path, "manage.py"), "migrate", "--run-syncdb"]
    execute_from_command_line(command)
513261
def init_config(loader)
      case loader
      when String, Hash, nil
        @config_loader = ConfigLoaders::FileOrHashLoader.new(loader)
      else
        @config_loader = loader
      end
      load_config
    end
5166
@Override
    public void init(Configuration conf) {
        String rootName = conf.get(ConfigConstants.CONF_DELIMITED_ROOT_NAME, 
                DEFAULT_ROOT_NAME);
        rootStart = '<' + rootName + '>';
        rootEnd = "</" + rootName + '>';
        
    }
140298
def _init_config(self):
        # type: (CliContext) -> None
        
        # load yaml config file into memory
        if blobxfer.util.is_not_empty(self.cli_options['yaml_config']):
            yaml_config = pathlib.Path(self.cli_options['yaml_config'])
            self._read_yaml_file(yaml_config)
        if self.config is None:
            self.config = {}
        # merge "global" cli options with config
        settings.merge_global_settings(self.config, self.cli_options)
        # set log file if specified
        logfile = self.config['options'].get('log_file', None)
        blobxfer.util.setup_logger(logger, logfile)
        # set azure storage logging level
        azstorage_logger = logging.getLogger('azure.storage')
        if self.config['options'].get('enable_azure_storage_logger', False):
            blobxfer.util.setup_logger(azstorage_logger, logfile)
            azstorage_logger.setLevel(logging.INFO)
        else:
            # disable azure storage logging: setting logger level to CRITICAL
            # effectively disables logging from azure storage
            azstorage_logger.setLevel(logging.CRITICAL)
        # set verbose logging
        if self.config['options'].get('verbose', False):
            blobxfer.util.set_verbose_logger_handlers()
        # output mixed config
        if self.show_config:
            logger.debug('config: \n{}'.format(
                json.dumps(self.config, indent=4)))
            logger.debug('cli config: \n{}'.format(
                json.dumps(
                    self.cli_options[self.cli_options['_action']],
                    indent=4, sort_keys=True)))
        del self.show_config
586883
def _init_config(self, width, height, spi=None, spiMosi= None, spiDC=None, spiCS=None, spiReset=None, spiClk=None):
        
        self._spi = spi
        self._spi_mosi = spiMosi
        self._spi_dc = spiDC
        self._spi_cs = spiCS
        self._spi_reset = spiReset
        self._spi_clk = spiClk

        self.width = width
        self.height = height
1236609
def initialize(**kwargs):
    
    global config
    config_opts = kwargs.setdefault('config',{})

    if isinstance(config_opts,basestring):
        config_opts = {'config_filename':config_opts}
        kwargs['config'] = config_opts

    if 'environment' in kwargs:
        config_opts['environment'] = kwargs['environment']

    config.load_config(**config_opts)

    # Overlay the subconfig
    if kwargs.get('name'):
        subconfig = config.get(kwargs.get('name'),{})
        config.overlay_add(subconfig)

    config.overlay_add(app_config)
32141
def init_app(self, app, conf_key=None):
        
        conf_key = conf_key or self.conf_key or 'PYMEMCACHE'
        self.conf_key = conf_key
        conf = app.config[conf_key]
        if not isinstance(conf, dict):
            raise TypeError("Flask-PyMemcache conf should be dict")

        close_on_teardown = conf.pop('close_on_teardown', False)

        if isinstance(conf['server'], list):
            conf['servers'] = conf.pop('server')
            client = pymemcache.client.hash.HashClient(**conf)
        elif isinstance(conf['server'], tuple):
            client = pymemcache.client.Client(**conf)
        else:
            raise TypeError("Flask-PyMemcache conf['server'] should be tuple or list of tuples")

        app.extensions.setdefault('pymemcache', {})
        app.extensions['pymemcache'][self] = client

        if close_on_teardown:
            @app.teardown_appcontext
            def close_connection(exc=None):
                client.close()
169380
public final void init(final ConfigurationState configState) {
    final ConstraintValidatorFactory configConstraintValidatorFactory =
        configState.getConstraintValidatorFactory();
    constraintValidatorFactory = configConstraintValidatorFactory == null
        ? GWT.<ConstraintValidatorFactory>create(ConstraintValidatorFactory.class)
        : configConstraintValidatorFactory;
    final TraversableResolver configTraversableResolver = configState.getTraversableResolver();
    traversableResolver = configTraversableResolver == null ? new DefaultTraversableResolver()
        : configTraversableResolver;
    final MessageInterpolator configMessageInterpolator = configState.getMessageInterpolator();
    messageInterpolator = configMessageInterpolator == null ? new GwtMessageInterpolator()
        : configMessageInterpolator;
    parameterNameProvider = configState.getParameterNameProvider();
  }
1019539
public void initialize(URI name, Configuration conf) throws IOException {
    fs.initialize(name, conf);
  }
136030
protected function init($conf)
    {
        $this->conf = $conf;
        $this->pi_setPiVarDefaults();
        $this->pi_loadLL('EXT:tt_address/Resources/Private/Language/locallang_pi1.xlf');
        $this->pi_initPIflexForm();

        // flexform data
        $flexKeyMapping = [
            'sDEF.singleRecords' => 'singleRecords',
            'sDEF.groupSelection' => 'groupSelection',
            'sDEF.combination' => 'combination',
            'sDEF.sortBy' => 'sortBy',
            'sDEF.sortOrder' => 'sortOrder',
            'sDEF.pages' => 'pages',
            'sDEF.recursive' => 'recursive',
            'sDISPLAY.templateFile' => 'templateFile',
        ];
        $this->ffData = $this->getFlexFormConfig($flexKeyMapping);

        //set default combination to AND if no combination set
        $combination = 'AND';
        if (!empty($this->ffData['combination']) || !empty($this->conf['combination'])) {
            // 0 and '0' are considered empty, therefore anything else means 1/true => OR
            $combination = 'OR';
        }
        $this->conf['combination'] = $combination;

        // check sorting, priorize FlexForm configuration over TypoScript
        if ($this->ffData['sortBy'] && $this->ffData['sortBy'] !== 'default') {
            // sortBy from FlexForm overrides TypoScript configuration
            $this->conf['sortByColumn'] = $this->ffData['sortBy'];
        }

        // check sorting column for validity, use default column "name" if column is invalid or not set
        $this->conf['sortByColumn'] = $this->checkSorting($this->conf['sortByColumn']);

        //set sorting, set to ASC if not valid
        $sortOrder = $this->ffData['sortOrder'] ?: $this->conf['sortOrder'];
        $this->conf['sortOrder'] = strtoupper($sortOrder) === 'DESC' ? SORT_DESC : SORT_ASC;

        // overwrite TS pidList if set in flexform
        $pages = !empty($this->ffData['pages']) ? $this->ffData['pages'] :
            trim($this->cObj->stdWrap($this->conf['pidList'], $this->conf['pidList.']));
        $pages = $pages ?
            implode(GeneralUtility::intExplode(',', $pages), ',') :
            $this->getTypoScriptFrontendController()->id;

        $recursive = (int)($this->ffData['recursive'] ?: $this->conf['recursive']);

        $this->conf['pidList'] = $this->pi_getPidList($pages, $recursive);

        $this->conf['singleSelection'] = $this->ffData['singleRecords'] ?:
            $this->cObj->stdWrap($this->conf['singleSelection'], $this->conf['singleSelection.']);

        $this->conf['groupSelection'] = $this->ffData['groupSelection'] ?:
            $this->cObj->stdWrap($this->conf['groupSelection'], $this->conf['groupSelection.']);

        $this->conf['templateName'] = $this->getTemplateName();
    }
484323
def get_instance(in_memory=False, config_path=None, config_name=None):
  
  global __conf

  if __conf is None:
    __conf = Configuration(in_memory=in_memory, custom_cfg_path=config_path, config_name=config_name)

  return __conf
15920
def load_conf(fn=None):
    
    if fn is None:
        fn = cfile()
    if os.path.isfile(fn):
        with open(fn) as f:
            try:
                conf.update(yaml_load(f))
            except Exception as e:
                logger.warning('Failure to load config file "{fn}": {e}'
                               ''.format(fn=fn, e=e))
201921
def configure(self, options, conf):
        
        self.conf = conf
        if hasattr(options, self.enable_opt):
            self.enabled = getattr(options, self.enable_opt)
66338
def init_config(self):
        """"""

        input_fpath = os.path.join(self.work_path, 'input.nml')

        input_nml = f90nml.read(input_fpath)

        if self.expt.counter == 0 or self.expt.repeat_run:
            input_type = 'n'
        else:
            input_type = 'r'
        input_nml['MOM_input_nml']['input_filename'] = input_type

        f90nml.write(input_nml, input_fpath, force=True)
612777
def initialize(self, configfile=None):
        

        method = "initialize"

        A = None
        metadata = {method: configfile}

        send_array(self.socket, A, metadata)
        A, metadata = recv_array(
            self.socket, poll=self.poll, poll_timeout=self.poll_timeout,
            flags=self.zmq_flags)
539155
def _init(self, clnt):
        ''''''
        assert clnt, "clnt is None"
        self._clnt = clnt
        self._apikey = clnt.apikey()
        self._version = clnt.conf(YP_VERSION, defval=VERSION_V2)
        self._charset = clnt.conf(HTTP_CHARSET, defval=CHARSET_UTF8)
        self._name = self.__class__.__module__.split('.')[-1]