Start a new config variable entry.
481952
def start_config_var_entry(self, var_id, encoded_selector):
        """"""

        selector = SlotIdentifier.FromEncoded(encoded_selector)

        err = self.config_database.start_entry(selector, var_id)
        return [err]
1327532
def init(name, runtime):
    """"""
    runtime = click.unstyle(runtime)

    stdout.write(
        style.format_command(
            'Initializing',
            '%s %s %s' % (name, style.gray('@'), style.green(runtime))
        )
    )

    config = Config(os.getcwd())
    config.set('runtime', runtime)
    config.save()

    generate.main(['init', name], standalone_mode=False)
    run.main(['python', 'manage.py', 'migrate'])
606584
function initConfig(obj) {
  Object.keys(obj).forEach(item => {
    if (!process.env[item]) {
      process.env[item] = obj[item];
    }
  });
}
174013
def initialize(config):
	""
	config = init_config(config)

	_setup_logging()
	_load_library_extensions()
	if not Handler._registry:
		raise RuntimeError("No handlers registered")

	class_ = _load_bot_class()

	config.setdefault('log_channels', [])
	config.setdefault('other_channels', [])

	channels = config.log_channels + config.other_channels

	log.info('Running with config')
	log.info(pprint.pformat(config))

	host = config.get('server_host', 'localhost')
	port = config.get('server_port', 6667)

	return class_(
		host,
		port,
		config.bot_nickname,
		channels=channels,
		password=config.get('password'),
	)
387334
public void run() {
    LOGGER.debug("begin scan for config file changes ...");
    try {
      Date lastModified = new Date(_xmlConfigFile.lastModified());

      if (_lastTimeRead == null || lastModified.after(_lastTimeRead)) {
        LOGGER.info("loading config file changes ...");
        this.loadServiceConfigFile();
        _lastTimeRead = new Date();
      }
    } catch (ConfigurationException e) {
      e.printStackTrace();
      LOGGER.error( "Error loading configuation file: ", e );
    }
    LOGGER.debug("finish scan for config file changes");
  }
794533
public static function start() : void
  {
    $required = Config::$environment;
    $dotenv   = new Dotenv(Config::$root);

    $dotenv->overload();
    $dotenv->required($required);
  }
459529
def init_config(self, app):
        
        _vars = ['BASE_TEMPLATE', 'COVER_TEMPLATE', 'SETTINGS_TEMPLATE']

        # Sets RequireJS config and SASS binary as well if not already set.
        for k in dir(config):
            if k.startswith('THEME_') or k in [
                    'REQUIREJS_CONFIG', 'SASS_BIN'] + _vars:
                app.config.setdefault(k, getattr(config, k))

        # Set THEME_<name>_TEMPLATE from <name>_TEMPLATE variables if not
        # already set.
        for varname in _vars:
            theme_varname = 'THEME_{}'.format(varname)
            if app.config[theme_varname] is None:
                app.config[theme_varname] = app.config[varname]

        app.config.setdefault(
            'ADMIN_BASE_TEMPLATE', config.ADMIN_BASE_TEMPLATE)
145157
def set_config_variable(self, config_id, offset, value):
        """"""

        if self.initialized.is_set():
            return [Error.STATE_CHANGE_AT_INVALID_TIME]

        config = self._config_variables.get(config_id)
        if config is None:
            return [Error.INVALID_ARRAY_KEY]

        error = config.update_value(offset, value)
        return [error]
568962
function start(mode, target, system, containerDef, container, out, cb) {
    if (mode !== 'preview') {
      main.setup(config, mode, target, system, containerDef, container, out, cb);
    } else {
      cb();
    }
  }
1011659
def _setup(self):
        """"""
        default_settings.reload()
        environment_variable = self._kwargs.get(
            "ENVVAR_FOR_DYNACONF", default_settings.ENVVAR_FOR_DYNACONF
        )
        settings_module = os.environ.get(environment_variable)
        self._wrapped = Settings(
            settings_module=settings_module, **self._kwargs
        )
        self.logger.debug("Lazy Settings _setup ...")
478585
@Override
	public void open(Configuration config) throws IOException {
		streamer.open();
		streamer.sendBroadCastVariables(config);
	}
588437
def init_app(self, app):
        """"""
        prefix_len = len(self.prefix)
        for varname, value in os.environ.items():
            if not varname.startswith(self.prefix):
                continue

            # Prepare values
            varname = varname[prefix_len:]
            value = value or app.config.get(varname)

            # Evaluate value
            try:
                value = ast.literal_eval(value)
            except (SyntaxError, ValueError):
                pass

            # Set value
            app.config[varname] = value
1249313
def start(inqueue, outqueue=None):
    """"""
    conf.init(), db.init(conf.DbPath)
    Listener(inqueue, outqueue).run()
913087
def current(config):
    """"""
    with open(config, 'r'):
        main.current(yaml.load(open(config)))
604437
def init(ctx, force):
    """"""
    if os.path.exists(PROJECT_CONFIG) and not force:
        click.secho(
            'An existing configuration file was found at "{}".\n'
            .format(PROJECT_CONFIG),
            fg='red', bold=True
        )
        click.secho(
            'Please remove it before in order to run the setup wizard or use\n'
            'the --force flag to overwrite it.'
        )
        ctx.exit(1)

    project_key = click.prompt('Project key on the issue tracker')
    base_branch = click.prompt('Integration branch', default='master')

    virtualenvs = ('.venv', '.env', 'venv', 'env')
    for p in virtualenvs:
        if os.path.exists(os.path.join(p, 'bin', 'activate')):
            venv = p
            break
    else:
        venv = ''
    venv_path = click.prompt('Path to virtual environment', default=venv)

    project_id = click.prompt('Project ID on Harvest', type=int)
    task_id = click.prompt('Task id on Harvest', type=int)

    config = configparser.ConfigParser()

    config.add_section('lancet')
    config.set('lancet', 'virtualenv', venv_path)

    config.add_section('tracker')
    config.set('tracker', 'default_project', project_key)

    config.add_section('harvest')
    config.set('harvest', 'project_id', str(project_id))
    config.set('harvest', 'task_id', str(task_id))

    config.add_section('repository')
    config.set('repository', 'base_branch', base_branch)

    with open(PROJECT_CONFIG, 'w') as fh:
        config.write(fh)

    click.secho('\nConfiguration correctly written to "{}".'
                .format(PROJECT_CONFIG), fg='green')
1047912
def _handle_config(self, data):
        """"""

        self.room.config.update(data)
        self.conn.enqueue_data("config", data)
594876
function start(CB, env) {

    var app = this;

    /*
     |--------------------------------------------------------------------------
     | Register The Environment Variables
     |--------------------------------------------------------------------------
     |
     | Here we will register all of the ENV variables into the
     | process so that they're globally available configuration options so
     | sensitive configuration information can be swept out of the code.
     |
     */
    (new EnvironmentVariables(app.getEnvironmentVariablesLoader())).load(env);

    /*
     |--------------------------------------------------------------------------
     | Register The Configuration Repository
     |--------------------------------------------------------------------------
     |
     | The configuration repository is used to lazily load in the options for
     | this application from the configuration files. The files are easily
     | separated by their concerns so they do not become really crowded.
     |
     */
    app.config = new Config(
        app.getConfigLoader(), env
    );

    // Set additional configurations
    app.config.set('cache.etagFn', utils.compileETag(app.config.get('cache').etag));
    app.config.set('middleware.queryParserFn', utils.compileQueryParser(app.config.get('middleware').queryParser));
    app.config.set('request.trustProxyFn', utils.compileTrust(app.config.get('request').trustProxy));

    // Expose use method globally
    global.use = app.use.bind(app);

    // Register user aliases for Positron modules
    app.alias(app.config.get('app.aliases', {}));

    /*
     |--------------------------------------------------------------------------
     | Register Booted Start Files & Expose Globals
     |--------------------------------------------------------------------------
     |
     | Once the application has been booted we will expose app globals as per
     | user configuration. Also there are several "start" files
     | we will want to include. We'll register our "booted" handler here
     | so the files are included after the application gets booted up.
     |
     */
    app.booted(function() {
        // expose app globals
        app.exposeGlobals();

        /*
         |--------------------------------------------------------------------------
         | Load The Application Start Script
         |--------------------------------------------------------------------------
         |
         | The start scripts gives this application the opportunity to do things
         | that should be done right after application has booted like configure
         | application logger, load filters etc. We'll load it here.
         |
         */
        var appStartScript = app.path.app + "/start/global.js";


        /*
         |--------------------------------------------------------------------------
         | Load The Environment Start Script
         |--------------------------------------------------------------------------
         |
         | The environment start script is only loaded if it exists for the app
         | environment currently active, which allows some actions to happen
         | in one environment while not in the other, keeping things clean.
         |
         */
        var envStartScript = app.path.app + "/start/" + env + ".js";


        /*
         |--------------------------------------------------------------------------
         | Load The Application Routes
         |--------------------------------------------------------------------------
         |
         | The Application routes are kept separate from the application starting
         | just to keep the file a little cleaner. We'll go ahead and load in
         | all of the routes now and return the application to the callers.
         |
         */
        var routes = app.path.app + "/routes.js";

        async.filter([appStartScript, envStartScript, routes], fs.exists, function (results) {
            results.forEach(function (path) {
                require(path);
            });

            CB(app);
        });
    });

    /*
     |--------------------------------------------------------------------------
     | Register The Core Service Providers
     |--------------------------------------------------------------------------
     |
     | The Positron core service providers register all of the core pieces
     | of the Positron framework including session, auth, encryption
     | and more. It's simply a convenient wrapper for the registration.
     |
     */
    var providers = app.config.get('app').providers;

    app.getProviderRepository().load(providers, function() {

        /*
         |--------------------------------------------------------------------------
         | Boot The Application
         |--------------------------------------------------------------------------
         |
         | Once all service providers are loaded we will  call the boot method on
         | application which will boot all service provider's and eventually boot the
         | positron application.
         |
         */
        app.boot();
    });

}