Just like ``get_option`` but parse as an integer.
347956
def get_option_int(self, name, section=None, vars=None, expect=None):
        """"""
        val = self.get_option(name, section, vars, expect)
        if val:
            return int(val)
361721
def _get_value(self, value, default):
        """"""
        vtype = type(default)

        if vtype is bool:
            return value.get_bool()
        elif vtype is str:
            return value.get_string()
        elif vtype is int:
            return value.get_int()
        elif vtype in (list, tuple):
            l = []
            for i in value.get_list():
                l.append(i.get_string())
            return l

        return None
212835
def as_int(self, val: Tuple[str]) -> int:
        """"""
        res = 0
        try:
            for b in val:
                res += 1 << self.bit[b]
        except KeyError:
            return None
        return res
1124177
def parse_options(self, option_values):
        
        self.set_options_values(option_values, parse=True)
        return self.get_options_values(hidden=False)
314333
def get_option_default(option):
    
    return (
        option.dest, 
        None if option.default is optparse.NO_DEFAULT else option.default,
    )
319582
function parseOptions(options) {
		options = options || {};
		return {
			boolean: "boolean" in options ? Boolean(options.boolean) : true,
			number: "number" in options ? Boolean(options.number) : true,
			string: "string" in options ? Boolean(options.string) : true
		};
	}
1217950
def get_int(self, key, optional=False):
        
        return self._get_typed_value(key, int, lambda x: int(x), optional)
941674
def parse_options(**kwargs):
    """"""
    return {camelize(key): value
            for key, value in kwargs.items()
            if value is not None}
1321661
def _arg2opt(arg):
    '''
    
    '''
    res = [o for o, a in option_toggles.items() if a == arg]
    res += [o for o, a in option_flags.items() if a == arg]
    return res[0] if res else None
176305
def get(key, default=-1):
        """"""
        if isinstance(key, int):
            return OptionNumber(key)
        if key not in OptionNumber._member_map_:
            extend_enum(OptionNumber, key, default)
        return OptionNumber[key]
257035
def parse_val(cfg,section,option):
    """"""
    vals = parse_vals(cfg,section,option)
    if len(vals)==0:
        return ''
    else:
        assert len(vals)==1, (section, option, vals, type(vals))
    return vals[0]
393025
def _parse_options(options: List[str]) -> Dict[str, str]:
    
    try:
        return dict(i.split('=', maxsplit=1) for i in options)
    except ValueError:
        raise ArgumentError(
            f'Option must be in format <key>=<value>, got: {options}')
509280
def as_int(value, default = 0)
      res = default

      if value
        if value.is_a?(Fixnum)
          res = value
        elsif value.respond_to?(:to_i)
          res = value.to_i
        end
      end

      res
    end
809778
def parse_options():
    

    try:
        opts, args = getopt.getopt(sys.argv[1:], 'ac:e:hilms:t:vx',
                ['adapt', 'comp=', 'enum=', 'exhaust', 'help', 'incr', 'blo',
                    'minimize', 'solver=', 'trim=', 'verbose'])
    except getopt.GetoptError as err:
        sys.stderr.write(str(err).capitalize())
        usage()
        sys.exit(1)

    adapt = False
    exhaust = False
    cmode = None
    to_enum = 1
    incr = False
    blo = False
    minz = False
    solver = 'g3'
    trim = 0
    verbose = 1

    for opt, arg in opts:
        if opt in ('-a', '--adapt'):
            adapt = True
        elif opt in ('-c', '--comp'):
            cmode = str(arg)
        elif opt in ('-e', '--enum'):
            to_enum = str(arg)
            if to_enum != 'all':
                to_enum = int(to_enum)
            else:
                to_enum = 0
        elif opt in ('-h', '--help'):
            usage()
            sys.exit(0)
        elif opt in ('-i', '--incr'):
            incr = True
        elif opt in ('-l', '--blo'):
            blo = True
        elif opt in ('-m', '--minimize'):
            minz = True
        elif opt in ('-s', '--solver'):
            solver = str(arg)
        elif opt in ('-t', '--trim'):
            trim = int(arg)
        elif opt in ('-v', '--verbose'):
            verbose += 1
        elif opt in ('-x', '--exhaust'):
            exhaust = True
        else:
            assert False, 'Unhandled option: {0} {1}'.format(opt, arg)

    return adapt, blo, cmode, to_enum, exhaust, incr, minz, solver, trim, \
            verbose, args
973535
def raw_get(option)
      value = options_storage[option]
      Confo.callable_without_arguments?(value) ? value.call : value
    end
823384
def parse_int(int_str):
    """"""
    int_str = int_str.replace(',', '')

    factor = __get_factor(int_str)
    if factor != 1:
        int_str = int_str[:-1]

    try:
        return int(int_str.replace(',', '')) * factor
    except ValueError:
        return None
228670
def _parse_options(opts, delim):
    """"""
    options = _CaseInsensitiveDictionary()
    for uriopt in opts.split(delim):
        key, value = uriopt.split("=")
        if key.lower() == 'readpreferencetags':
            options.setdefault(key, []).append(value)
        else:
            if key in options:
                warnings.warn("Duplicate URI option '%s'." % (key,))
            options[key] = unquote_plus(value)

    if 'tlsInsecure' in options:
        for implicit_option in _IMPLICIT_TLSINSECURE_OPTS:
            if implicit_option in options:
                warn_msg = "URI option '%s' overrides value implied by '%s'."
                warnings.warn(warn_msg % (options.cased_key(implicit_option),
                                          options.cased_key('tlsInsecure')))
                continue
            options[implicit_option] = options['tlsInsecure']

    return options