Update a BuildConfigurationSet
770341
def update_build_configuration_set(id, **kwargs):
    
    data = update_build_configuration_set_raw(id, **kwargs)
    if data:
        return utils.format_json(data)
600726
def update_configuration(self, **kwargs):
        
        updated = False
        if 'announced_networks' in kwargs:
            kwargs.update(announced_ne_setting=kwargs.pop('announced_networks'))
        if 'bgp_profile' in kwargs:
            kwargs.update(bgp_profile_ref=kwargs.pop('bgp_profile'))
        if 'autonomous_system' in kwargs:
            kwargs.update(bgp_as_ref=kwargs.pop('autonomous_system'))
        
        announced_ne = kwargs.pop('announced_ne_setting', None)
        
        for name, value in kwargs.items():
            _value = element_resolver(value)
            if self.data.get(name) != _value:
                self.data[name] = _value
                updated = True
        
        if announced_ne is not None:
            s = self.data.get('announced_ne_setting')
            ne = self._unwrap(announced_ne)
            
            if len(announced_ne) != len(s) or not self._equal(ne, s):
                self.data.update(announced_ne_setting=ne)
                updated = True
            
        return updated
317189
def update(self, reconfigure=False):
        
        try:
            self.phase = PHASE.UPDATE
            self.logger.info("Updating environment %s..." % self.namespace)
            self.install_sandboxes()
            self.instantiate_features()
            # We don't grab inputs, only on install
            # updates inputs are grabbed on demand
            # self.grab_inputs(reconfigure=reconfigure)
            if reconfigure:
                self.grab_inputs(reconfigure=True)
            else:
                self._copy_source_to_target()
            self._specialize(reconfigure=reconfigure)
            for feature in self.features.run_order:
                self.run_action(feature, 'sync')
            self.inject_environment_config()
            self._finalize()
        except Exception:
            self.logger.debug("", exc_info=sys.exc_info())
            et, ei, tb = sys.exc_info()
            reraise(et, ei, tb)
899627
def add_build_configuration_to_set(
        set_id=None, set_name=None, config_id=None, config_name=None):
    
    content = add_build_configuration_to_set_raw(set_id, set_name, config_id, config_name)
    if content:
        return utils.format_json(content)
1288845
@Override
	public void configurationSourceUpdated(final ConfigurationSource source) {
		ConfigurationManager.INSTANCE.reconfigure(key, configurable, environment);
	}
725426
def builds(self, confs):
        """"""
        self._named_builds = {}
        self._builds = []
        for values in confs:
            if len(values) == 2:
                self._builds.append(BuildConf(values[0], values[1], {}, {}, self.reference))
            elif len(values) == 4:
                self._builds.append(BuildConf(values[0], values[1], values[2], values[3],
                                              self.reference))
            elif len(values) != 5:
                raise Exception("Invalid build configuration, has to be a tuple of "
                                "(settings, options, env_vars, build_requires, reference)")
            else:
                self._builds.append(BuildConf(*values))
227780
def setConfiguration(self, configuration):
        
        """
        if isinstance(configuration, Configuration):
           configuration = configuration.value

        self.dev.set_configuration(configuration)
667087
def updateFromKwargs(self, properties, kwargs, collector, **unused):
        """'"""
        properties[self.name] = self.getFromKwargs(kwargs)
554773
def update_config(self):
        
        dataset = self._top._config.dataset
        session = object_session(self._top._config)
        logger.debug(
            'Updating group config. dataset: {}, type: {}, key: {}'.format(dataset.vid, self._top._type, self._key))

        self._config, created = _get_config_instance(
            self, session,
            parent_id=self._parent._config.id, d_vid=dataset.vid,
            group=self._key, key=self._key, type=self._top._type, dataset = dataset)
        if created:
            self._top._cached_configs[self._get_path()] = self._config
        self._top._add_valid(self._config)

        if created:
            logger.debug(
                'New group config created and linked. config: {}'.format(self._config))
        else:
            logger.debug(
                'Existing group config linked. config: {}'.format(self._config))
884165
@RequestMapping(value = "configurations/{name:.*}/update", method = RequestMethod.PUT)
    public SVNConfiguration updateConfiguration(@PathVariable String name, @RequestBody SVNConfiguration configuration) {
        svnConfigurationService.updateConfiguration(name, configuration);
        return getConfiguration(name);
    }
1129998
def update_config(config):
    

    # Update the default config with whatever is in the passed config
    update(bigchaindb.config, update_types(config, bigchaindb.config))
    bigchaindb.config['CONFIGURED'] = True
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
1369213
public void raConfigurationUpdate(ConfigProperties properties) {
        try {
            Set<String> oldTransports = new HashSet<String>(this.transports);
            raConfigure(properties);
        } catch (Throwable ex) {
            String msg = "error while updating RA configuration";
            tracer.severe(msg, ex);
            throw new RuntimeException(msg,ex);
        }
    }
676498
function configure(build) {
  // Configure from file.
  var data = build.tryRequireNew(build.filePath);
  if (!data)
    return;
  configureBase(build, data);
  configurePaths(build, data);
  configureApiProxy(build, data);
  configurePackage(build, data);
  configureDevServer(build, data);
  configureEngine(build, data);
  configureHashids(build, data);
  configureLocales(build, data);
  configureBundles(build, data);
  configureViews(build, data);
}
178356
def with_updated_configuration(self, options=None,
                                   attribute_options=None):
        
        return self._mapping.with_updated_configuration(options=options,
                                                        attribute_options=
                                                            attribute_options)
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)
    }
  })
}