Returns a dictionary of option value for a given component
    
    See :func:`arguments_from_optionable` documentation
170579
def get_config_for(args, component, prefix=""):
    
    config = {}
    vargs = vars(args)
    for option in component.options:
        if component.options[option].hidden:
            continue
        config[option] = vargs["%s%s" % (prefix, option)]
    return config
1278720
def to_dict(self):
        
        result = super(OptionHandler, self).to_dict()
        result["type"] = "OptionHandler"
        result["options"] = join_options(self.options)
        return result
1324062
def get_option_value(elem):
    
    value = elem.get("value")
    if value is None:
        value = elem.text.strip()
    if value is None or value == "":
        msg = u"Error parsing value from {}.".format(elem)
        raise ValueError(msg)

    return value
1239183
def value(self):
        
        pvalue = {}
        for key in self._value:
            pvalue[key] = self._value[key].value
        return pvalue
911277
def []=(key, val)
      supported_option?(key) || raise(UnsupportedOptionError, key.inspect)
      values[key] = val
    end
216212
def GetValue(self):
    '''
    
    '''
    self.AssertInitialization('Choice')
    if self._widget.GetValue() == self._DEFAULT_VALUE:
      return None
    return ' '.join(
      [self._action.option_strings[0] if self._action.option_strings else '',  # get the verbose copy if available
       self._widget.GetValue()])
816944
def _get_params(func, *args, **kwargs):
    
    params = dict(zip(func.func_code.co_varnames[:len(args)], args))
    if func.func_defaults:
        params.update(dict(zip(
            func.func_code.co_varnames[-len(func.func_defaults):],
            func.func_defaults)))
    params.update(kwargs)

    return params
490612
def _options_to_dict(df):
    """"""
    kolums = ["k1", "k2", "value"]
    d = df[kolums].values.tolist()
    dc = {}
    for x in d:
        dc.setdefault(x[0], {})
        dc[x[0]][x[1]] = x[2]
    return dc
1124177
def parse_options(self, option_values):
        
        self.set_options_values(option_values, parse=True)
        return self.get_options_values(hidden=False)
379181
def get(self, value, cfg=None):
        
        if value is None and cfg:
            if self.option_type == 'list':
                value = cfg.get_list(self.name, None)
            else:
                value = cfg.get(self.name, None)

        if value is None:
            value = self.default
        else:
            parse_method = getattr(self, 'parse_%s' % (self.option_type), None)
            if parse_method:
                value = parse_method(value)
        return value
1197388
def getValue(self):
        
        actions = self._actions

        if (type (actions) is list):
            dict = actions[0]
        else:
            dict = actions
        return dict.get('value', 'NoValue')
188956
def extract_props(self, settings):
        '''
        
        '''

        props = {}

        for param in self.call_parameters:
            if param in settings:
                props[param] = settings[param]
            else:
                props[param] = None

        return props
941674
def parse_options(**kwargs):
    """"""
    return {camelize(key): value
            for key, value in kwargs.items()
            if value is not None}
258498
def get_by_type(self, _type):
        
        r = {}
        for k, v in self.items():
            if get_component_type(k) is _type:
                r[k] = v
        return r
227883
def getComponent(self, innerFlag=False):
        
        if self._currentIdx is None:
            raise error.PyAsn1Error('Component not chosen')
        else:
            c = self._componentValues[self._currentIdx]
            if innerFlag and isinstance(c, Choice):
                return c.getComponent(innerFlag)
            else:
                return c
397128
def __get_options(self, rouge_args=None):
        
        if self.args:
            options = self.args.split()
        elif rouge_args:
            options = rouge_args.split()
        else:
            options = [
                '-e', self._data_dir,
                '-c', 95,
                '-2',
                '-1',
                '-U',
                '-r', 1000,
                '-n', 4,
                '-w', 1.2,
                '-a',
                ]
            options = list(map(str, options))

        options = self.__add_config_option(options)
        return options
1299818
def get_option_list(self, name, section=None, vars=None,
                        expect=None, separator=','):
        
        val = self.get_option(name, section, vars, expect)
        return val.split(separator) if val else []