Search method by name and number of args
Returns: The types of the arguments
332810
private function search_pg_proc ($method, $args) {
    $argtypenames = array ();
    $argtypeschemas = array ();
    $nargs = count ($args);

    $query = "SELECT * FROM pgprocedures.search_function ('".$this->name."', '$method', $nargs)";
    
    $rettypename = null;

    if ($res = $this->pgproc_query ($query)) {
      if ($row = pg_fetch_array ($res)) {
	$schema = $row['proc_nspname'];
	$argtypes = $row['proargtypes'];
	$rettype = $row['prorettype'];

	// Get the arguments types
	$argtypeslist = explode (' ', $argtypes);
	foreach ($argtypeslist as $argtype) {
	  if (!strlen (trim ($argtype)))
	    continue;

	  list($argtypeschemas[], $argtypenames[]) = $this->get_pgtype_and_schema ($argtype);
	}

	if ((in_array($row['ret_typtype'], array('b', 'p', 'e')))) { // scalar type: (b)ase, (p)seudo-type, (e)num
	  $rettypename = $row['ret_typname'];
	  
	} else if ($row['ret_typtype'] == 'c') { // composite type
	  $query3 = "select attname, typname FROM pg_attribute INNER JOIN pg_type ON pg_attribute.atttypid = pg_type.oid WHERE pg_attribute.attrelid = (select oid FROM pg_class where relname = '".$row['ret_typname']."') AND attnum > 0 ORDER BY attnum";
	  if ($res3 = $this->pgproc_query ($query3)) {
	    $rettypename = array();
	    while ($row3 = pg_fetch_array ($res3)) {
	      $rettypename[$row3['attname']] =  $row3['typname'];
	    }
	  }
	}

      }
    }
    if (count ($argtypenames) == $nargs)
      return array ($schema, $argtypeschemas, $argtypenames, $row['ret_typtype'], $rettypename, ($row['proretset'] == 't'));
    else
      return NULL;
  }
1173179
def argument_types(self):
        
        class ArgumentsIterator(collections.Sequence):
            def __init__(self, parent):
                self.parent = parent
                self.length = None

            def __len__(self):
                if self.length is None:
                    self.length = conf.lib.clang_getNumArgTypes(self.parent)

                return self.length

            def __getitem__(self, key):
                # FIXME Support slice objects.
                if not isinstance(key, int):
                    raise TypeError("Must supply a non-negative int.")

                if key < 0:
                    raise IndexError("Only non-negative indexes are accepted.")

                if key >= len(self):
                    raise IndexError("Index greater than container length: "
                                     "%d > %d" % ( key, len(self) ))

                result = conf.lib.clang_getArgType(self.parent, key)
                if result.kind == TypeKind.INVALID:
                    raise IndexError("Argument could not be retrieved.")

                return result

        assert self.kind == TypeKind.FUNCTIONPROTO
        return ArgumentsIterator(self)
1343922
def check_argument_types(cllable = None, call_args = None, clss = None, caller_level = 0):
    
    return _check_caller_type(False, cllable, call_args, clss, caller_level+1)
39969
def func_args(func):
    '''
    '''
    try:
        return tuple(inspect.signature(func).parameters)
    except:
        return tuple(inspect.getargspec(func).args)
141737
def findArgs(args, prefixes):
		
		return list([
			arg for arg in args
			if len([p for p in prefixes if arg.lower().startswith(p.lower())]) > 0
		])
610562
function search (args) {
    // add session if not set
    if (!args.session) {
        args.session = this.session
    }
    // return original method call
    return this.model.search(args)
}
433063
def get_arg_type_descriptors(self):
        

        if not self.is_method:
            return tuple()

        tp = _typeseq(self.get_descriptor())
        tp = _typeseq(tp[0][1:-1])

        return tp
1222300
def types(*args, **kwargs):
    

    rtype = first(args)

    return Types(rtype=rtype, ptypes=kwargs)
410927
def noargs(self):
        ""
        noargs = inspect.ArgSpec(args=[], varargs=None, keywords=None, defaults=None)
        return self.argspec == noargs
1208068
def _get_type_hints(func, args = None, res = None, infer_defaults = None):
    
    if args is None or res is None:
        args2, res2 = _get_types(func, util.is_classmethod(func),
                util.is_method(func), unspecified_type = type(NotImplemented),
                infer_defaults = infer_defaults)
        if args is None:
            args = args2
        if res is None:
            res = res2
    slf = 1 if util.is_method(func) else 0
    argNames = util.getargnames(util.getargspecs(util._actualfunc(func)))
    result = {}
    if not args is Any:
        prms = get_Tuple_params(args)
        for i in range(slf, len(argNames)):
            if not prms[i-slf] is type(NotImplemented):
                result[argNames[i]] = prms[i-slf]
    result['return'] = res
    return result
1171593
def arg_name(self) -> T.Optional[str]:
        """"""
        if len(self.args) > 2:
            return self.args[2]
        elif len(self.args) > 1:
            return self.args[1]
        return None
129947
def all_methods(cls):
        
        def name(fn):
            return fn.__get__(cls).__name__.replace("_", "-")
        return sorted(name(f) for f in cls.__dict__.values()
                      if isinstance(f, staticmethod))
335489
def with_known_args(self, **kwargs):
    """"""
    argspec = inspect.getargspec(self.func)
    stored = {}
    for key, arg in six.iteritems(kwargs):
      if key in argspec.args or argspec.keywords:
        stored[key] = arg
    if stored:
      return self.with_args(**stored)
    return self
342491
def args_match(m_args, m_kwargs, default, *args, **kwargs):
    
    if len(m_args) > len(args):
        return False
    for m_arg, arg in zip(m_args, args):
        matches = arg_match(m_arg, arg, eq)
        if not matches or matches is InvalidArg:
            return False  # bail out

    if m_kwargs:
        for name, m_arg in m_kwargs.items():
            name, comparator = arg_comparitor(name)
            arg = kwargs.get(name)
            if not arg_match(m_arg, arg, comparator, default):
                return False  # bail out
    return True
516929
def _GetArgsDescription(self, args_type):
    """"""
    args = {}
    if args_type:
      for type_descriptor in args_type.type_infos:
        if not type_descriptor.hidden:
          args[type_descriptor.name] = {
              "description": type_descriptor.description,
              "default": type_descriptor.default,
              "type": "",
          }
          if type_descriptor.type:
            args[type_descriptor.name]["type"] = type_descriptor.type.__name__
    return args
274113
public static Object[] findMethodWithExactParameters(Object service, String methodName, List<?> args) {
        Object[] arguments = new Object[args.size()];
        for (int i = 0; i < args.size(); i++) {
            arguments[i] = args.get(i);
        }
        return findMethodWithExactParameters(service, methodName, arguments);
    }
96585
def get_args(self):
        
        for table in self.tables + self.with_tables:
            if type(table) is QueryTable:
                self._where.args.update(table.query.get_args())

        return self._where.args