returns a dict where the keys are the config_ids and the values
		are the actual configurations
517595
def get_id2config_mapping(self):
		
		new_dict = {}
		for k, v in self.data.items():
			new_dict[k] = {}
			new_dict[k]['config'] = copy.deepcopy(v.config)
			try:
				new_dict[k]['config_info'] = copy.deepcopy(v.config_info)
			except:
				pass
		return(new_dict)
788730
def as_dict(self, use_preliminary=False):
        
        config = dict()
        for key in self.config.keys:
            if use_preliminary and key in self.preliminary_config:
                value = self.preliminary_config[key]
            else:
                value = self.config.get_config_value(key)
            config[key] = value
        return config
1171279
def named_config(name: str, config_dict: typing.Mapping) -> None:
    
    names = (
        name
        if isinstance(name, Iterable) and not isinstance(name, (str, bytes))
        else [name]
    )
    for each in names:
        _config_registry[each] = Config(**config_dict)
1054326
def _co_names_from_config(self):
        
        co_names = [co[self.KEY_ENCODEABLE_NAME] for
                    co in self.config[self.KEY_CO]]

        return co_names
450696
def _to_dict(self):
        """"""
        _dict = {}
        if hasattr(self, 'configurations') and self.configurations is not None:
            _dict['configurations'] = [
                x._to_dict() for x in self.configurations
            ]
        return _dict
678041
def find_existing_configs(self, default):
        '''
        
        '''
        configs = []
        for cfg in [default, self._config_filename_, 'minion', 'proxy', 'cloud', 'spm']:
            if not cfg:
                continue
            config_path = self.get_config_file_path(cfg)
            if os.path.exists(config_path):
                configs.append(cfg)

        if default and default not in configs:
            raise SystemExit('Unknown configuration unit: {}'.format(default))

        return configs
389707
def get_config_dict(config):
    '''
    
    '''
    dst = {}
    tmp = config.__dict__
    key_list = dir(config)
    key_list.remove('os')
    for k, v in tmp.items():
        if k in key_list and not k.startswith('_'):
            dst[k] = v
    return dst
140973
def configurations(self):
        """"""

        if self._confs is not None:
            return self._confs

        with output_capturing():
            module = self.load(self.fpath)
            confs = getattr(module, CONFIGS_MODULE_ATTR)
            confs = listify(confs)

        self._confs = confs

        return confs
1328936
def getConfig(self, type='online', format='elegant'):
        
        return list(list(self.dumpConfigDict[type](format).values())[0].values())[0]
815294
def config_value_keys(self, sortkey = False):
        
        if sortkey:
            items = sorted(self.items())
        else:
            items = self.items()
        return (k for k,v in items if not isinstance(v,ConfigTree))
1241720
def get_configurations(self):
        

        project_configurations_dictionary = {}
        project_configurations = self.project.project_configurations()

        # Create project specific configurations dictionary
        for config in project_configurations:
            project_configurations_dictionary[config.key] = config

        stage_configurations_dictionary = {}
        stage_configurations = self.stage_configurations()

        # Create stage specific configurations dictionary
        for s in stage_configurations:
            stage_configurations_dictionary[s.key] = s

        # override project specific configuration with the ones in the stage if they are there
        project_configurations_dictionary.update(stage_configurations_dictionary)

        # Return the updated configurations
        return project_configurations_dictionary
762385
def __get_config():
    '''
    
    '''
    if 'config' not in globals():
        return None
    cfg = globals().get('config', None)
    if cfg is None:
        return None

    if not isinstance(cfg, dict):
        return None
    return cfg
418803
def as_dict(config):
    
    settings = defaultdict(lambda: {})
    for section in config.sections():
        for key, val in config.items(section):
            settings[section][key] = val
    return settings
1150912
def config(self):
        

        return dict((optname, getattr(self, optname))
                    for optname, _ in CFG_OPTIONS if hasattr(self, optname))
1040114
def get_configuration(self):
        
        mapping = {}
        settings = self.get_settings()
        for service in self.context.getService():
            uid = api.get_uid(service)
            setting = settings.get(uid, {})
            config = {
                "hidden": setting.get("hidden", False),
            }
            mapping[uid] = config
        return mapping
49270
def process_config_dict(self, key, d, level):
        
        lines = []
        for k, v in d.items():
            k = "CONFIG {}".format(self.quoter.add_quotes(k.upper()))
            v = self.quoter.add_quotes(v)
            lines.append(self.__format_line(self.whitespace(level, 1), k, v))
        return lines
367430
def get_config(self):
        
        # Fill this dict with config data
        return {
            'hash_name': self.hash_name,
            'dim': self.dim,
            'projection_count': self.projection_count,
            'normals': self.normals,
            'tree_root': self.tree_root,
            'minimum_result_size': self.minimum_result_size
        }