Get the arguments
353938
def getArguments():
    
    parser = ArgumentParser(description = 'CA utility')
    parser.add_argument('--base', dest = 'basePath', default = '.', help = 'The base working directory')
    subParsers = parser.add_subparsers(dest = 'action')
    # The init parser
    initParser = subParsers.add_parser('init', help = 'Initialize the database')
    # Vertify certificatae
    verifyParser = subParsers.add_parser('verify', help = 'Verify certificate')
    verifyParser.add_argument('--name', dest = 'name', required = True, help = 'The certificate name')
    # Create root certificate parser
    createRootCertParser = subParsers.add_parser('createRootCert', help = 'Create root certificate')
    createRootCertParser.add_argument('--nopass', dest = 'noPass', default = False, action = 'store_true', help = 'Generate root key without a password (Not recommended), false by default.')
    createRootCertParser.add_argument('--keylen', dest = 'keyLength', default = '4096', choices = [ '2048', '4096' ], help = 'The root key length, 4096 by default')
    # Create server certificate parser
    createServerCertParser = subParsers.add_parser('createServerCert', help = 'Create server cert')
    createServerCertParser.add_argument('--name', dest = 'name', required = True, help = 'The certificate name')
    createServerCertParser.add_argument('--usepass', dest = 'usePass', default = False, action = 'store_true', help = 'Generate key with a password, false by default.')
    createServerCertParser.add_argument('--keylen', dest = 'keyLength', default = '2048', choices = [ '2048', '4096' ], help = 'The key length, 2048 by default')
    createServerCertParser.add_argument('--days', dest = 'days', type = int, default = 3650, help = 'The certificate days parameter')
    # Create client certificate parser
    createClientCertParser = subParsers.add_parser('createClientCert', help = 'Create server cert')
    createClientCertParser.add_argument('--name', dest = 'name', required = True, help = 'The certificate name')
    createClientCertParser.add_argument('--usepass', dest = 'usePass', default = False, action = 'store_true', help = 'Generate key with a password, false by default.')
    createClientCertParser.add_argument('--keylen', dest = 'keyLength', default = '2048', choices = [ '2048', '4096' ], help = 'The key length, 2048 by default')
    createClientCertParser.add_argument('--days', dest = 'days', type = int, default = 3650, help = 'The certificate days parameter')
    # Done
    return parser.parse_args()
876689
def get_args(request_args, allowed_int_args=[], allowed_str_args=[]):
    """"""
    args = {}

    for allowed_int_arg in allowed_int_args:
        int_value = request_args.get(allowed_int_arg, default=None, type=None)
        if int_value:
            args[allowed_int_arg] = int(int_value)

    for allowed_str_arg in allowed_str_args:
        str_value = request_args.get(allowed_str_arg, default=None, type=None)
        if str_value:
            args[allowed_str_arg] = str_value

    return args
958464
def _get_command_args(self, command, args):
        ''''''
        command_args = {}
        command_argument_names =\
            command.__code__.co_varnames[:command.__code__.co_argcount]

        for varname in command_argument_names:
            if varname == 'args':
                command_args['args'] = args
            elif varname in self.provide_args:
                command_args[varname] = self.provide_args[varname]
            else:
                command_args[varname] = getattr(args, varname)
        return command_args
506787
def get_arguments(self, name: str, strip: bool = True) -> List[str]:
        

        # Make sure `get_arguments` isn't accidentally being called with a
        # positional argument that's assumed to be a default (like in
        # `get_argument`.)
        assert isinstance(strip, bool)

        return self._get_arguments(name, self.request.arguments, strip)
1184654
def args(self) -> str:
        """"""
        return '{}{}{}{}{}'.format(
            to_ascii_hex(self._index, 2),
            to_ascii_hex(self._group_number, 2),
            to_ascii_hex(self._unit_number, 2),
            to_ascii_hex(int(self._enable_status), 4),
            to_ascii_hex(int(self._switches), 4))
595789
def get_kwargs(args, exp_keys, exp_elems):
    """"""
    arg_dict = {}    # For arguments that have values
    for key, val in args.items():
        if exp_keys is not None and key in exp_keys and val:
            if isinstance(val, str):
                val = val.strip()
            arg_dict[key] = val
        elif exp_elems is not None and key in exp_elems and val:
            arg_dict[key] = True
    return arg_dict
1186139
private Object[] getArgumentsValues()
	{
		Argument[] args = getArguments();
		Object[] result = new Object[args.length];
		for (int i = 0; i < args.length; ++i)
		{
			result[i] = args[i].getValue();
		}
		return result;
	}
1155499
def get_args(request_args, allowed_int_args=(), allowed_str_args=(), allowed_bool_args=()):
    """"""
    args = {}

    for allowed_int_arg in allowed_int_args:
        int_value = request_args.get(allowed_int_arg, default=None, type=None)

        if int_value:
            args[allowed_int_arg] = int(int_value)

    for allowed_str_arg in allowed_str_args:
        str_value = request_args.get(allowed_str_arg, default=None, type=None)

        if str_value:
            args[allowed_str_arg] = str_value

    for allowed_bool_arg in allowed_bool_args:
        str_value = request_args.get(allowed_bool_arg, default=None, type=None)

        if str_value == 'true':
            args[allowed_bool_arg] = True

        elif str_value == 'false':
            args[allowed_bool_arg] = False

    return args
780145
def getArguments(parser):
    ""
    args = parser.parse_args()
    # parse volume and adapt to zero-indexing
    try:
        def _to_int_or_none(string):
            if 0 == len(string): return None
            return int(string)
        def _to_int_or_none_double (string):
            if 0 == len(string): return [None, None]
            return list(map(_to_int_or_none, string.split(':')))        
        args.volume = list(map(_to_int_or_none_double, args.volume.split(',')))
        args.volume = [(x[0], x[1]) for x in args.volume]
    except (ValueError, IndexError) as e:
        raise ArgumentError('Maleformed volume parameter "{}", see description with -h flag.'.format(args.volume), e)

    return args
789362
def getArguments(parser):
    ""
    args = parser.parse_args()
    if args.order < 0 or args.order > 5:
        parser.error('The order has to be a number between 0 and 5.')   
    return args
884923
def getArguments(names, local_dict=None, global_dict=None):
    """"""
    call_frame = sys._getframe(2)

    clear_local_dict = False
    if local_dict is None:
        local_dict = call_frame.f_locals
        clear_local_dict = True
    try:
        frame_globals = call_frame.f_globals
        if global_dict is None:
            global_dict = frame_globals

        # If `call_frame` is the top frame of the interpreter we can't clear its 
        # `local_dict`, because it is actually the `global_dict`.
        clear_local_dict = clear_local_dict and not frame_globals is local_dict

        arguments = []
        for name in names:
            try:
                a = local_dict[name]
            except KeyError:
                a = global_dict[name]
            arguments.append(numpy.asarray(a))
    finally:
        # If we generated local_dict via an explicit reference to f_locals,
        # clear the dict to prevent creating extra ref counts in the caller's scope
        # See https://github.com/pydata/numexpr/issues/310
        if clear_local_dict:
            local_dict.clear()

    return arguments
291993
def args(self):  # as args tuple
        '''
        '''
        return (self.base, self.item, self.leng, self.refs,
                self.both, self.kind, self.type)
305672
def get_args(job):
    
    return tuple(_get_args_loop(job, INPUT_FIELD)), \
        tuple(_get_args_loop(job, OPTIONAL_FIELD))
1356807
def get_context_arguments(self):
        """"""
        cargs = {}
        for context in self.__context_stack:
            cargs.update(context.context_arguments)
        return cargs
376377
def _get_args(self, kwargs):
        '''
        
        '''
        _args = list()
        _kwargs = salt.utils.args.clean_kwargs(**kwargs)

        return _args, _kwargs
827640
def get_args(self):
        
        return [
            self.task_cls.__module__,
            self.task_cls.__name__,
            self.encode_list(self.task_params),
            self.encode_list(self.branches),
            self.encode_bool(self.auto_retry),
            self.encode_list(self.dashboard_data),
        ]
246918
def request_args(self):
        '''
        
        '''
        kwargs = {}
        kwargs.update(self.request.match_info.items())
        kwargs.update(self.request.query.items())
        return kwargs