Gets the list of named arguments for the target function

    :param target:
        Function for which the argument names will be retrieved
487674
def get_arg_names(target) -> typing.List[str]:
    

    code = getattr(target, '__code__')

    if code is None:
        return []

    arg_count = code.co_argcount
    kwarg_count = code.co_kwonlyargcount
    args_index = get_args_index(target)
    kwargs_index = get_kwargs_index(target)

    arg_names = list(code.co_varnames[:arg_count])
    if args_index != -1:
        arg_names.append(code.co_varnames[args_index])
    arg_names += list(code.co_varnames[arg_count:(arg_count + kwarg_count)])
    if kwargs_index != -1:
        arg_names.append(code.co_varnames[kwargs_index])
    if len(arg_names) > 0 and arg_names[0] in ['self', 'cls']:
        arg_count -= 1
        arg_names.pop(0)

    return arg_names
214289
def get_listeners(self, name):
                
        return list(map(lambda listener: listener[0], self.listeners[name]))
468367
def arguments(self):
        
        if not self.is_function:
            raise ValueError('expected function value, got %s' % (self._kind,))
        it = ffi.lib.LLVMPY_FunctionArgumentsIter(self)
        parents = self._parents.copy()
        parents.update(function=self)
        return _ArgumentsIterator(it, parents)
653974
def _construct_target(self, function):
        
        target = {
                'Arn': function.get_runtime_attr("arn"),
                'Id': self.logical_id + 'LambdaTarget'
        }
        if self.Input is not None:
            target['Input'] = self.Input

        if self.InputPath is not None:
            target['InputPath'] = self.InputPath
        return target
793086
def get_targets(conn=None):
    
    targets = RBT
    results = targets.run(conn)
    for item in results:
        yield item
503472
def get_kwarg_names(func):
    
    sig = inspect.signature(func)
    kwonlyargs = [p.name for p in sig.parameters.values()
                  if p.default is not p.empty]
    return kwonlyargs
1326481
def get_signature(name, func):
    
    args, varargs, keywords, defaults = inspect.getargspec(func)
    defaults = defaults or []
    posargslen = len(args) - len(defaults)
    if varargs is None and keywords is None:
        sig = name + '('
        sigargs = []
        for idx, arg in enumerate(args):
            if idx < posargslen:
                sigargs.append(arg)
            else:
                default = repr(defaults[idx - posargslen])
                sigargs.append(arg + '=' + default)
        sig += ', '.join(sigargs) + ')'
        return sig
    elif not args and varargs and not keywords and not defaults:
        return name + '(*' + varargs + ')'
    else:
        raise InvalidTask('ape tasks may not use **kwargs')
378565
def target(self):
        
        return [
            os.path.basename(os.path.dirname(f)) for f in self.files
        ]
1156826
def get_args_tuple(args, kwargs, arg_names, kwargs_defaults):
    """"""
    args_list = list(args)
    args_len = len(args)
    all_args_len = len(arg_names)
    try:
        while args_len < all_args_len:
            arg_name = arg_names[args_len]
            if arg_name in kwargs_defaults:
                args_list.append(kwargs.get(arg_name, kwargs_defaults[arg_name]))
            else:
                args_list.append(kwargs[arg_name])
            args_len += 1
    except KeyError as e:
        raise TypeError("Missing argument %r" % (e.args[0],))
    return tuple(args_list)
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
463945
def get_args(method_or_func):
    """"""
    try:
        # Python 3.0+
        args = list(inspect.signature(method_or_func).parameters.keys())
    except AttributeError:
        # Python 2.7
        args = inspect.getargspec(method_or_func).args
    return args
505297
def get_kwargs(kwargs):
    
    return {
        key: value for key, value in six.iteritems(kwargs)
        if key != 'self'
    }
1375045
static List<EventMethod> getMethodsForTarget(@NonNull Object target) {
        if (target instanceof Class) {
            return getMethodsFromClass((Class<?>) target, true);
        } else {
            return getMethodsFromClass(target.getClass(), false);
        }
    }
906133
def get_current_args(caller_level = 0, func = None, argNames = None):
    
    if argNames is None:
        argNames = getargnames(getargspecs(func))
    if func is None:
        func = get_current_function(caller_level+1)
    if isinstance(func, property):
        func = func.fget if func.fset is None else func.fset
    stck = inspect.stack()
    lcs = stck[1+caller_level][0].f_locals
    return tuple([lcs[t] for t in argNames])
687812
def _get_arguments(self, action_node):
        
        arguments = {}
        argument_nodes = action_node.iterfind(
            r'./ns:argumentList/ns:argument', namespaces={'ns': self.namespace})
        for argument_node in argument_nodes:
            argument = self._get_argument(argument_node)
            arguments[argument.name] = argument
        return arguments
243665
def get_args
      bin_path = get_binpath
      target   = get_target
      center   = get_center
      jd       = get_jd
      km       = get_km
      check_bin_path(bin_path)
      check_target_center(target, center)
      return [bin_path, target, center, jd, km]
    rescue => e
      raise
    end
929257
def _get_args(op, name):
    
    # Could use multipledispatch here to avoid the pasta
    if isinstance(op, ops.Selection):
        assert name is not None, 'name is None'
        result = op.selections

        # if Selection.selections is always columnar, could use an
        # OrderedDict to prevent scanning the whole thing
        return [col for col in result if col._name == name]
    elif isinstance(op, ops.Aggregation):
        assert name is not None, 'name is None'
        return [
            col
            for col in itertools.chain(op.by, op.metrics)
            if col._name == name
        ]
    else:
        return op.args