Updating one configuration
510886
@RequestMapping(value = "configurations/{name:.*}/update", method = RequestMethod.PUT)
    public GitHubEngineConfiguration updateConfiguration(@PathVariable String name, @RequestBody GitHubEngineConfiguration configuration) {
        configurationService.updateConfiguration(name, configuration);
        return getConfiguration(name);
    }
448573
def update_configuration(app):
    """"""
    config = app.config
    project = config.project
    config_dir = app.env.srcdir
    sys.path.insert(0, os.path.join(config_dir, '..'))

    config.html_theme_path.append(os.path.relpath(os.path.join(os.path.abspath(os.path.dirname(__file__)), 'themes'), config_dir))
    if not config.html_logo:
        config.html_logo = os.path.relpath(os.path.join(STATIC_PATH, 'safari_logo.png'), config_dir)
    if not config.html_favicon:
        config.html_favicon = os.path.relpath(os.path.join(STATIC_PATH, 'favicon.ico'), config_dir)
    config.html_static_path.append(os.path.relpath(STATIC_PATH, config_dir))
    if not config.htmlhelp_basename:
        config.htmlhelp_basename = '%sdoc' % project
    if not config.latex_logo:
        config.latex_logo = os.path.relpath(os.path.join(STATIC_PATH, 'safari_logo.png'), config_dir)
    if not config.epub_title:
        config.epub_title = u'%s Documentation' % project
    if not config.epub_publisher:
        config.epub_publisher = config.epub_author
    if not config.epub_copyright:
        config.epub_copyright = config.copyright

    config.latex_documents.append(
        (master_doc,
         '%s.tex' % project,
         u'%s Documentation' % project,
         u'Safari',
         'manual'))
    config.man_pages.append(
        (master_doc,
         project,
         u'%s Documentation' % project,
         [u'Safari'],
         1))
    config.texinfo_documents.append(
        (master_doc,
         project,
         u'%s Documentation' % project,
         u'Safari',
         project,
         'One line description of project.',
         'Miscellaneous'))

    # Parse the version number from setup.py without actually running setup()
    with open(os.path.join(config_dir, '..', 'setup.py'), 'r') as f:
        content = f.read()
        match = re.search(r"version\s*=\s*['\"]([\d\.]+)['\"]", content)
        if match:
            config.version = match.group(1)
            config.release = config.version
936157
def autoconfigure(filename=None, config=None, force=False):
    
    if not force and is_configured():
        logger.debug('System already configured, skipping autoconfiguration')
        return

    # start with the current configuration
    newconfig = bigchaindb.config

    # update configuration from file
    try:
        newconfig = update(newconfig, file_config(filename=filename))
    except FileNotFoundError as e:
        if filename:
            raise
        else:
            logger.info('Cannot find config file `%s`.' % e.filename)

    # override configuration with env variables
    newconfig = env_config(newconfig)
    if config:
        newconfig = update(newconfig, config)
    set_config(newconfig)
665
def update_build_configuration(id, **kwargs):
    
    data = update_build_configuration_raw(id, **kwargs)
    if data:
        return utils.format_json(data)
201214
def merge_config(self, user_config):
        '''
        
        '''

        # provisioanlly update the default configurations with the user preferences
        temp_data_config = copy.deepcopy(self.data_config).update(user_config)
        temp_model_config = copy.deepcopy(self.model_config).update(user_config)
        temp_conversation_config = copy.deepcopy(self.conversation_config).update(user_config)

        # if the new configurations validate, apply them
        if validate_data_config(temp_data_config):
            self.data_config = temp_data_config
        if validate_model_config(temp_model_config):
            self.model_config = temp_model_config
        if validate_conversation_config(temp_conversation_config):
            self.conversation_config = temp_conversation_config
140505
def reconfig(main_parser, args=sys.argv[1:]):

    """"""

    parsed, remaining_args = parser().parse_known_args(args)
    configure(parsed.config_paths, os.getcwd())
    return main_parser().parse_args(remaining_args)
1130082
def update_repository_configuration(id, external_repository=None, prebuild_sync=None):
    
    to_update_id = id

    rc_to_update = pnc_api.repositories.get_specific(id=to_update_id).content

    if external_repository is None:
        external_repository = rc_to_update.external_url
    else:
        rc_to_update.external_url = external_repository

    if prebuild_sync is not None:
        rc_to_update.pre_build_sync_enabled = prebuild_sync

    if not external_repository and prebuild_sync:
        logging.error("You cannot enable prebuild sync without external repository")
        return

    response = utils.checked_api_call(pnc_api.repositories, 'update', id=to_update_id, body=rc_to_update)
    if response:
        return response.content
1026974
def _update_config(self,directory,filename):
        """"""
        basefilename=os.path.splitext(filename)[0]
        ext=os.path.splitext(filename)[1].lower()
        if filename==LOCATION_FILE:
            print("%s - Updating geotag information"%(LOCATION_FILE))
            return self._update_config_location(directory)
        elif filename==TAG_FILE:
            print("%s - Updating tags"%(TAG_FILE))
            return self._update_config_tags(directory)
        elif filename==SET_FILE:
            print("%s - Updating sets"%(SET_FILE))
            return self._update_config_sets(directory)
        elif filename==MEGAPIXEL_FILE:
            print("%s - Updating photo size"%(MEGAPIXEL_FILE))
            return self._upload_media(directory,resize_request=True)
        elif ext in self.FLICKR_META_EXTENSIONS:
            return self._update_meta(directory,basefilename)

        return False
1075134
def _update_cinder_config(cls):
        """"""
        cls._config_string_io.seek(0)
        cls._parser.write(cls._config_string_io)

        # Check if we have any multiopt
        cls._config_string_io.seek(0)
        current_cfg = cls._config_string_io.read()
        if '\n\t' in current_cfg:
            cls._config_string_io.seek(0)
            cls._config_string_io.write(current_cfg.replace('\n\t', '\n'))

        cls._config_string_io.seek(0)
        cfg.CONF.reload_config_files()
1004228
def update_conf(self):
        
        parsed = self.parse_conf()

        if not parsed:
            return None

        # Update app config
        self.app.config.update(parsed)
1260915
function updateConfigs (args, newVersion) {
  const dotgit = DotGitignore()
  Bump.pkgFiles.concat(Bump.lockFiles).forEach(function (filename) {
    let configPath = path.resolve(process.cwd(), filename)
    try {
      if (dotgit.ignore(configPath)) return
      let stat = fs.lstatSync(configPath)
      if (stat.isFile()) {
        let data = fs.readFileSync(configPath, 'utf8')
        let indent = detectIndent(data).indent
        let newline = detectNewline(data)
        let config = JSON.parse(data)
        checkpoint(args, 'bumping version in ' + filename + ' from %s to %s', [config.version, newVersion])
        config.version = newVersion
        writeFile(args, configPath, stringifyPackage(config, indent, newline))
        // flag any config files that we modify the version # for
        // as having been updated.
        configsToUpdate[filename] = true
      }
    } catch (err) {
      if (err.code !== 'ENOENT') console.warn(err.message)
    }
  })
}
104903
def updateConfig(self, eleobj, config, type='simu'):
        
        eleobj.setConf(config, type=type)
545104
public function updateConfig(){
	
		foreach($this->_config as $name => $val){
		
			$method = '__Set'._camelize($name);
			
			if(method_exists($this,$method)){
				$this->_config[$name] = call_user_func(array($this,$method),$val);
			}
		}
		return $this;
	}
1202490
def update_configuration(configuration):
    
    for key, val in REQUIRED_SETTINGS.items():
        if val in ["$username", "$groupname"]:
            val = get_username()

        configuration = conf_writer.add_or_update(configuration, key, val)

    return configuration
178356
def with_updated_configuration(self, options=None,
                                   attribute_options=None):
        
        return self._mapping.with_updated_configuration(options=options,
                                                        attribute_options=
                                                            attribute_options)
227780
def setConfiguration(self, configuration):
        
        """
        if isinstance(configuration, Configuration):
           configuration = configuration.value

        self.dev.set_configuration(configuration)
1319746
public function updateConfiguration()
    {
        $this->getEventDispatcher()->dispatch(
            UpdateConfigurationEvent::NAME,
            new UpdateConfigurationEvent($this->getWebserviceId(), $this->getConfiguration())
        );
    }