extended config copy cfg
973604
function getContent(modalId, opts) {
        var data = {
          modalId: modalId,
          theme: opts.theme,
          header: opts.header,
          fullScreen: opts.fullScreen ? "fullscreen" : "",
          styles: "",
          iframe: opts.iframe,
          iframeLoadingMsg: opts.iframeLoadingMsg,
          disableResize: opts.disableResize
        };

        if (opts.zIndex) {
          data.styles += "z-index:" + opts.zIndex + ";";
        }
        if (opts.absolute) {
          data.styles += "position:absolute;";
        }

        if (data.iframe && typeof data.iframe.param === "string") {
          data.iframe.param = ax5.util.param(data.iframe.param);
        }

        return MODAL.tmpl.get.call(this, "content", data, {});
      }
627195
function _getConfig() {
        var copy = {},
            property;

        for (property in _config) {
            if (_config.hasOwnProperty(property)) {
                copy[property] = _config[property];
            }
        }
 
        return copy;
    }
957610
def _clone_config_and_srcmaps(config_path, seed):
        """"""
        workdir = os.path.dirname(config_path)
        new_config_path = config_path.replace('.yaml', '_%06i.yaml' % seed)
        config = load_yaml(config_path)
        comps = config.get('components', [config])
        for i, comp in enumerate(comps):
            comp_name = "%02i" % i
            if 'gtlike' not in comp:
                comp['gtlike'] = {}
            orig_srcmap = os.path.abspath(os.path.join(workdir, 'srcmap_%s.fits' % (comp_name)))
            new_srcmap = os.path.abspath(os.path.join(workdir, 'srcmap_%06i_%s.fits' % (seed, comp_name)))
            comp['gtlike']['srcmap'] = os.path.abspath(os.path.join(workdir, 'srcmap_%06i_%s.fits' % (seed, comp_name)))
            comp['gtlike']['use_external_srcmap'] = True
            copyfile(orig_srcmap, new_srcmap)

        write_yaml(config, new_config_path)
        return new_config_path
732746
protected function copyConfigFiles()
    {
        $this->displayMsgNLInCli(' > Copy config files : ');

        //No file to copy
        if ($this->configFilesList === []) {
            $this->displayMsgInCli(' >> ');
            $this->displayMsgNLInCli(
                'No config file declared. Pass',
                'yellow',
                'bold'
            );
            
            return;
        }

        //Create the module directory into the config directory.
        $this->createConfigDirectory();
        
        //Copy manifest json file
        $this->copyConfigFile('manifest.json');

        //Copy each config file declared
        foreach ($this->configFilesList as $configFileName) {
            $this->copyConfigFile($configFileName);
        }
    }
342530
def do_copy_config(self, line):
        

        def f(p, args):
            try:
                source, target = args
            except:
                print("argument error")
                return
            print(p.copy_config(source, target))

        self._request(line, f)
1073442
function copyJekyllConfig() {
    return streamToPromise(
        gulp.src(paths.src.jekyll)
            .pipe(rename('_config.yaml'))
            .pipe(gulp.dest(paths.out.docs.base))
    );
}
1019778
function setPkgConfig(loader, pkgName, cfg, prependConfig) {
  var pkg;

  // first package is config by reference for fast path, cloned after that
  if (!loader.packages[pkgName]) {
    pkg = loader.packages[pkgName] = cfg;
  }
  else {
    var basePkg = loader.packages[pkgName];
    pkg = loader.packages[pkgName] = {};

    extendPkgConfig(pkg, prependConfig ? cfg : basePkg, pkgName, loader, prependConfig);
    extendPkgConfig(pkg, prependConfig ? basePkg : cfg, pkgName, loader, !prependConfig);
  }
  
  // main object becomes main map
  if (typeof pkg.main == 'object') {
    pkg.map = pkg.map || {};
    pkg.map['./@main'] = pkg.main;
    pkg.main['default'] = pkg.main['default'] || './';
    pkg.main = '@main';
  }

  return pkg;
}
1278233
function clone(conf) {
  if (typeof conf !== 'object') return conf;
  var obj = {};
  for (var key in conf) {
    obj[key] = clone(conf[key]);
  }
  return obj;
}
1217978
def _configure(self, config):
		
		config = config or dict()
		
		# We really need this to be there.
		if 'extensions' not in config: config['extensions'] = list()
		
		if not any(isinstance(ext, BaseExtension) for ext in config['extensions']):
			# Always make sure the BaseExtension is present since request/response objects are handy.
			config['extensions'].insert(0, BaseExtension())
		
		if not any(isinstance(ext, arguments.ArgumentExtension) for ext in config['extensions']):
			# Prepare a default set of argument mutators.
			config['extensions'].extend([
					arguments.ValidateArgumentsExtension(),
					arguments.ContextArgsExtension(),
					arguments.RemainderArgsExtension(),
					arguments.QueryStringArgsExtension(),
					arguments.FormEncodedKwargsExtension(),
					arguments.JSONKwargsExtension(),
				])
		
		config['extensions'].append(self)  # Allow the application object itself to register callbacks.
		
		try:
			addLoggingLevel('trace', logging.DEBUG - 5)
		except AttributeError:
			pass
		
		# Tests are skipped on these as we have no particular need to test Python's own logging mechanism.
		level = config.get('logging', {}).get('level', None)
		if level:  # pragma: no cover
			logging.basicConfig(level=getattr(logging, level.upper()))
		elif 'logging' in config:  # pragma: no cover
			logging.config.dictConfig(config['logging'])
		
		return config
860454
def apply_crtomo_cfg(self):
        
        for key in sorted(self.tds.keys()):
            self.tds[key].crtomo_cfg = self.crtomo_cfg.copy()
68412
def extend_config(config, config_items):
    
    for key, val in list(config_items.items()):
        if hasattr(config, key):
            setattr(config, key, val)

    return config
318699
def copy_config(project_path, output_dir):
    
    project_config = os.path.join(project_path, 'config.json')
    saved_config = os.path.join(output_dir, 'config.json')
    shutil.copy(project_config, saved_config)
911049
def _cfg(key, default=None):
    '''
    
    '''
    root_cfg = __salt__.get('config.get', __opts__.get)
    kms_cfg = root_cfg('aws_kms', {})
    return kms_cfg.get(key, default)
862171
def _generate_config(self, mapping_class):
        """"""
        config = mapping_class()
        self._walk_config_copy_values(
            self.option_definitions,
            config,
            mapping_class
        )
        return config
215511
def _discard_config(self):
        """"""
        discard_candidate = "copy running-config {}".format(
            self._gen_full_path(self.candidate_cfg)
        )
        discard_merge = "copy null: {}".format(self._gen_full_path(self.merge_cfg))
        self.device.send_command_expect(discard_candidate)
        self.device.send_command_expect(discard_merge)
1229098
function postConfig (context, _ref) {
  var merge = _ref.merge

  return function (prevConfig) {
    var _context$copyPlugin = context.copyPlugin,
      patterns = _context$copyPlugin.patterns,
      options = _context$copyPlugin.options

    var plugin = new _copyWebpackPlugin2.default(patterns, options)
    return merge({plugins: [plugin]})
  }
}
329351
def _clean_vdev_config(config):
    '''
    
    '''
    cln_config = OrderedDict()
    for label, sub_config in config.items():
        if label not in ['state', 'read', 'write', 'cksum']:
            sub_config = _clean_vdev_config(sub_config)

            if sub_config and isinstance(cln_config, list):
                cln_config.append(OrderedDict([(label, sub_config)]))
            elif sub_config and isinstance(cln_config, OrderedDict):
                cln_config[label] = sub_config
            elif isinstance(cln_config, list):
                cln_config.append(label)
            elif isinstance(cln_config, OrderedDict):
                new_config = []
                for old_label, old_config in cln_config.items():
                    new_config.append(OrderedDict([(old_label, old_config)]))
                new_config.append(label)
                cln_config = new_config
            else:
                cln_config = [label]

    return cln_config