Make a copy of the CFG.

        :return: A copy of the CFG instance.
        :rtype: angr.analyses.CFG
358820
def copy(self):
        
        new_cfg = CFGEmulated.__new__(CFGEmulated)
        super(CFGEmulated, self).make_copy(new_cfg)

        new_cfg._indirect_jump_target_limit = self._indirect_jump_target_limit
        new_cfg.named_errors = dict(self.named_errors)
        new_cfg.errors = list(self.errors)
        new_cfg._fail_fast = self._fail_fast
        new_cfg._max_steps = self._max_steps
        new_cfg.project = self.project

        # Intelligently (or stupidly... you tell me) fill it up
        new_cfg._edge_map = self._edge_map.copy()
        new_cfg._loop_back_edges = self._loop_back_edges[::]
        new_cfg._executable_address_ranges = self._executable_address_ranges[::]
        new_cfg._unresolvable_runs = self._unresolvable_runs.copy()
        new_cfg._overlapped_loop_headers = self._overlapped_loop_headers[::]
        new_cfg._thumb_addrs = self._thumb_addrs.copy()
        new_cfg._keep_state = self._keep_state

        return new_cfg
1016322
def _cfgs_to_read(self):
        
        # use these files to extend/overwrite the conf_values.
        # Last red file always overwrites existing values!
        cfg = Config.DEFAULT_CONFIG_FILE_NAME
        filenames = [
            self.default_config_file,
            cfg,  # conf_values in current directory
            os.path.join(os.path.expanduser('~' + os.path.sep), cfg),  # config in user dir
            '.pyemma.cfg',
        ]

        # look for user defined files
        if self.cfg_dir:
            from glob import glob
            filenames.extend(glob(self.cfg_dir + os.path.sep + "*.cfg"))
        return filenames
529597
def copy(self):
        
        return type(self)(reagents=[x.copy() for x in self.__reagents], meta=self.__meta.copy(),
                          products=[x.copy() for x in self.__products],
                          reactants=[x.copy() for x in self.__reactants])
388643
function(cfg, callback) {
  // Input files
  var inputPath = path.normalize(cfg.input_file);

  // Output dir
  var outputPath = path.normalize(cfg.output_file);

  if (cfg.input_file && cfg.output_file) {
    new gear.Queue({registry: taskRegistry}) // register tasks
    .log(formatLog('Copying file:', inputPath))
    .copyFile({input: inputPath, output: outputPath}, callback)
    .log(formatLog('Copied file to: ', outputPath))
    .run(callback);
  } else {
    callback();
  }
}
1098189
def copy(self):
        
        state_copy = State()
        state_copy._state_dict = copy.deepcopy(self._state_dict)
        return state_copy
507445
def clone(self):
        
        builder = LintConfigBuilder()
        builder._config_blueprint = copy.deepcopy(self._config_blueprint)
        builder._config_path = self._config_path
        return builder
1129950
public function save_cfg()
  {
    if ( $this->check() ){
      $this->db->update(
          $this->class_cfg['tables']['users'],
          [$this->fields['cfg'] => json_encode($this->cfg)],
          [$this->fields['id'] => $this->id]);
    }
    return $this;
  }
149430
def copy(self):
        ''' 

        '''
        return HSL(self.h, self.s, self.l, self.a)
771557
def copy(self):
        
        result = copy.deepcopy(self)
        result._cache.clear()
        return result
35935
def populate_cfg_dcnm(self, cfg, dcnm_obj):
        
        if not self.fw_init:
            return
        self.dcnm_obj = dcnm_obj
        self.fabric.store_dcnm(dcnm_obj)
        self.populate_dcnm_obj(dcnm_obj)
311594
def copy( self ):
        
        ret = ParseResults( self.__toklist )
        ret.__tokdict = self.__tokdict.copy()
        ret.__parent = self.__parent
        ret.__accumNames.update( self.__accumNames )
        ret.__name = self.__name
        return ret
290264
def copy(self):
        
        return self.filter(np.ones(self._num_fix).astype(bool))
651293
def copy(self):
        
        copied_model = GPModel(kernel = self.model.kern.copy(),
                            noise_var=self.noise_var,
                            exact_feval=self.exact_feval,
                            optimizer=self.optimizer,
                            max_iters=self.max_iters,
                            optimize_restarts=self.optimize_restarts,
                            verbose=self.verbose,
                            ARD=self.ARD)

        copied_model._create_model(self.model.X,self.model.Y)
        copied_model.updateModel(self.model.X,self.model.Y, None, None)
        return copied_model
823364
def load_settings(cfg_path=None):
    

    global settings

    cfg_path = cfg_path or _config['cfg_path']

    cfg_d = _config.copy()

    if os.path.exists(cfg_path):
        sfl = SourceFileLoader('upkg_cfg', cfg_path)
        cfg_mod = sfl.load_module()

        for m in inspect.getmembers(cfg_mod):
            if m[0][0] != '_':
                cfg_d[m[0]] = m[1]
        # end for m in inspect.getme

    # Make the paths absolute.
    cfg_d["cfg_path"] = _clean_path(cfg_d["cfg_path"])
    cfg_d["upkg_destdir"] = _clean_path(cfg_d["upkg_destdir"])

    settings = Namespace(**cfg_d)
361292
def _create_specs(self):
        

        raw_specs = self._get_raw_specs(self.config)
        spec = self._configobj_factory(infile=None,
                                       _inspec=True
                                       )

        for section, options in self.config.items():

            if section == 'global':
                continue

            if 'module' in options:
                module = options['module']
            else:
                raise ConfigMissingValue(section, 'module')

            spec.merge(self._configspec_factory(section=section,
                                                module=module,
                                                infile=raw_specs[module]
                                                )
                       )

        return spec
240655
def save_cfg_vals_to_git_cfg(**cfg_map):
    """"""
    for cfg_key_suffix, cfg_val in cfg_map.items():
        cfg_key = f'cherry-picker.{cfg_key_suffix.replace("_", "-")}'
        cmd = "git", "config", "--local", cfg_key, cfg_val
        subprocess.check_call(cmd, stderr=subprocess.STDOUT)
346741
def copy(self):
        
        a = Motif()
        a.__dict__ = self.__dict__.copy()
        return a