return keyword configuration as a dict

        Usage: rdict = getKwAsDict(kw)
768459
def getKwAsDict(self, kw):
        
        self.getKw(kw)
        return self.str2dict(self.confstr)
392524
def getKwCtrlConf(self, kw, fmt='dict'):
        
        try:
            confd = self.ctrlconf_dict[kw]
            if fmt == 'dict':
                retval = confd
            else:  # 'json' string for other options
                retval = json.dumps(confd)
        except KeyError:
            # try to get from raw line string
            self.getKw(kw)
            if self.confstr_epics != '':
                if fmt == 'dict':
                    retval = ast.literal_eval(self.confstr_epics)
                elif fmt == 'json':
                    retval = json.dumps(ast.literal_eval(self.confstr_epics))
                else:  # raw string
                    retval = self.confstr_epics
            else:
                retval = None

        return retval
1035506
def _from_dict(cls, _dict):
        """"""
        args = {}
        if 'folders' in _dict:
            args['folders'] = [
                SourceOptionsFolder._from_dict(x)
                for x in (_dict.get('folders'))
            ]
        if 'objects' in _dict:
            args['objects'] = [
                SourceOptionsObject._from_dict(x)
                for x in (_dict.get('objects'))
            ]
        if 'site_collections' in _dict:
            args['site_collections'] = [
                SourceOptionsSiteColl._from_dict(x)
                for x in (_dict.get('site_collections'))
            ]
        if 'urls' in _dict:
            args['urls'] = [
                SourceOptionsWebCrawl._from_dict(x) for x in (_dict.get('urls'))
            ]
        if 'buckets' in _dict:
            args['buckets'] = [
                SourceOptionsBuckets._from_dict(x)
                for x in (_dict.get('buckets'))
            ]
        if 'crawl_all_buckets' in _dict:
            args['crawl_all_buckets'] = _dict.get('crawl_all_buckets')
        return cls(**args)
828103
def dict(self):
        
        return {k: getattr(self, k) for k in self.__class__.defaults}
959449
def dict(self):
        
        from collections import OrderedDict
        SKIP_KEYS = ()
        return OrderedDict(
            (p.key, getattr(self, p.key)) for p in self.__mapper__.attrs if p.key not in SKIP_KEYS)
5075
def get_kws_plt(self):
        """"""
        kws_plt = {}
        for key_plt in self.keys_plt:
            key_val = getattr(self, key_plt, None)
            if key_val is not None:
                kws_plt[key_plt] = key_val
            elif key_plt in self.kws:
                kws_plt[key_plt] = self.kws[key_plt]
        return kws_plt
810130
def get_rm_conf(self):
        
        if not os.path.isfile(self.remove_file):
            return None

        # Convert config object into dict
        parsedconfig = ConfigParser.RawConfigParser()
        parsedconfig.read(self.remove_file)
        rm_conf = {}

        for item, value in parsedconfig.items('remove'):
            if six.PY3:
                rm_conf[item] = value.strip().encode('utf-8').decode('unicode-escape').split(',')
            else:
                rm_conf[item] = value.strip().decode('string-escape').split(',')

        return rm_conf
764894
def recursive_dict_to_dict(rdict):
    
    d = {}
    for (k, v) in rdict.items():
        if isinstance(v, defaultdict):
            d[k] = recursive_dict_to_dict(v)
        else:
            d[k] = v
    return d
1275724
def separateKeywords(kwArgsDict):
    
    standardKws = {}
    ourKws = {}
    for k in kwArgsDict:
        if k in STANDARD_KEYS:
            standardKws[k]=kwArgsDict[k]
        else:
            ourKws[k]=kwArgsDict[k]
    return (standardKws, ourKws)
1342667
def get_keyword(self, kwd, *args):
        """"""
        try:
            kwds = self.get_header()
            return kwds[kwd]
        except KeyError:
            # return a default if there is one
            if len(args) > 0:
                return args[0]
            raise KeyError(kwd)
209146
def getConfig(self, key):
        
        if hasattr(self, key):
            return getattr(self, key)
        else:
            return False
1055708
def as_dict(self):
        
        self.clean()
        d = OrderedDict()
        all_props = self.__class__.CONFIG_PROPERTIES
        for attr_name, attr_config in six.iteritems(all_props):
            value = self._config[attr_name]
            attr_type = attr_config.attr_type
            if attr_type:
                if value:
                    if issubclass(attr_type, list):
                        if issubclass(attr_type, NamedTupleList):
                            d[attr_name] = [i._asdict() for i in value]
                        else:
                            d[attr_name] = value[:]
                    elif attr_type is dict:
                        d[attr_name] = dict(value)
            elif value is not NotSet:
                d[attr_name] = value
        return d
3755
def str2dict(self, rawstr):
        
        kw_list = []
        sp1 = rawstr.split(':')
        kw_name = sp1[0].strip().upper()
        kw_desc = sp1[1:]
        sp2 = kw_desc[0].replace(',', ';;', 1).split(';;')
        kw_type = sp2[0].strip()
        try:
            kw_vals = sp2[1].replace(",", '=').split('=')
            [(not (i.isspace() or i == '')) and kw_list.append(i) for i in kw_vals]
            ks = [k.strip() for k in kw_list[0::2]]
            vs = [v.strip().replace('"', '').replace("'", '') for v in kw_list[1::2]]
            kw_vals_dict = dict(zip(ks, vs))
            rdict = {kw_name: {kw_type: kw_vals_dict}}
        except:
            rdict = {kw_name: kw_type}
        return rdict
1306529
def get_specific_config(prefix):
    
    conf_dict = {}
    for uuid, val in cfg.CONF.get(prefix, {}).items():
        conf_dict[uuid] = dict(val)
    return conf_dict
944470
def as_dict(self):
        """"""
        return {config_name: getattr(self, config_name)
                for config_name, _ in self._iter_config_props()}
1364612
def get_dict(cls):
        
        mdt = cls.get()

        if not mdt:
            return {}

        return conspectus.subs_by_mdt.get(mdt, {})
955262
def get_dict_from_response(response):
    """"""
    result = {}
    if getattr(response, '_resp') and response._resp.code > 400:
        return result

    for i in response.data:
        # strip the schema from the key
        k = i['Type'].replace(REMOTE_APP_RESOURCE_SCHEMA, '')
        result.setdefault(k, list())
        result[k].append(i['Value'])
    return result