inspect.getargspec

All Samples(1641) | Call(1482) | Derive(0) | Import(159)

Get the names and default values of a function's arguments.

A tuple of four things is returned: (args, varargs, varkw, defaults).
'args' is a list of the argument names (it may contain nested lists).
'varargs' and 'varkw' are the names of the * and ** arguments or None.
'defaults' is an n-tuple of the default values of the last n arguments.

Show Implementation

        def getargspec(func):
    """Get the names and default values of a function's arguments.

    A tuple of four things is returned: (args, varargs, varkw, defaults).
    'args' is a list of the argument names (it may contain nested lists).
    'varargs' and 'varkw' are the names of the * and ** arguments or None.
    'defaults' is an n-tuple of the default values of the last n arguments.
    """

    if ismethod(func):
        func = func.im_func
    if not isfunction(func):
        raise TypeError('{!r} is not a Python function'.format(func))
    args, varargs, varkw = getargs(func.func_code)
    return ArgSpec(args, varargs, varkw, func.func_defaults)

src/n/o/notmm-0.4.1/examples/contrib/app_plugins/templatetags/app_plugins.py notmm(Download)

"""plugins template tag root hooks.
"""
from django.conf import settings
from django.db.models.loading import get_app
from django import template
from inspect import getargspec
from django.template.context import Context

        >>> foo(b=2, a=1, d=3)
    """
    name = getattr(func, "_decorated_function", func).__name__
    params, varargs, varkw, defaults = getargspec(func)
    if takes_context:
        if params[0] == 'context':
            params.pop(0)

src/f/l/flioops-HEAD/py/trunk/utils/func.py flioops(Download)

# 			http://www.phyast.pitt.edu/%7Emicheles/python/documentation.html
 
 
from inspect import getmembers, getargspec, formatargspec, getargvalues, isclass, getargs
from sys import _getframe
from __builtin__ import min
from itertools import ifilter

def getArgsSignature(func):
	"""
	Retrieves the definition and call signature of a function 
	packaged in a tuple.
	"""
	args, varg, karg, defs= getargspec(func)
	return formatargspec(args, varg, karg, defs)[1: -1], formatargspec(args, varg, karg)[1: -1]
 
def getArgsNames(func, idxlist= None):
	"""
	Retrieves the names of a function arguments
	provided their position in its signature.
	"""
	args, varg, karg= getargspec(func)[:3]

def update_wrapper(wrapper, wrapped):
	"""
	Prepares a wrapper to look like wrapped function
	"""
	args, varg, karg, defs= getargspec(wrapped)
	fcall= formatargspec(args, varg, karg)[1: -1]

src/r/o/roreditor-HEAD/trunk/lib_windows/wx/lib/pubsub.py roreditor(Download)

 
# for function and method parameter counting:
from types   import InstanceType
from inspect import getargspec, ismethod, isfunction
# for weakly bound methods:
from new     import instancemethod as InstanceMethod
from weakref import ref as WeakRef

def _paramMinCountFunc(function):
    """Given a function, return pair (min,d) where min is minimum # of
    args required, and d is number of default arguments."""
    assert isfunction(function)
    (args, va, kwa, dflt) = getargspec(function)
    lenDef = len(dflt or ())
    lenArgs = len(args or ())

src/w/x/wxpy-HEAD/wx/lib/pubsub.py wxpy(Download)

 
# for function and method parameter counting:
from types   import InstanceType
from inspect import getargspec, ismethod, isfunction
# for weakly bound methods:
from new     import instancemethod as InstanceMethod
from weakref import ref as WeakRef

def _paramMinCountFunc(function):
    """Given a function, return pair (min,d) where min is minimum # of
    args required, and d is number of default arguments."""
    assert isfunction(function)
    (args, va, kwa, dflt) = getargspec(function)
    lenDef = len(dflt or ())
    lenArgs = len(args or ())

src/r/o/roreditor-HEAD/lib_windows/wx/lib/pubsub.py roreditor(Download)

 
# for function and method parameter counting:
from types   import InstanceType
from inspect import getargspec, ismethod, isfunction
# for weakly bound methods:
from new     import instancemethod as InstanceMethod
from weakref import ref as WeakRef

def _paramMinCountFunc(function):
    """Given a function, return pair (min,d) where min is minimum # of
    args required, and d is number of default arguments."""
    assert isfunction(function)
    (args, va, kwa, dflt) = getargspec(function)
    lenDef = len(dflt or ())
    lenArgs = len(args or ())

src/p/u/pubsub-HEAD/trunk/src/pubsub/pubsub1/pub.py pubsub(Download)

#---------------------------------------------------------------------------
 
# for function and method parameter counting:
from inspect import getargspec, ismethod, isfunction
# for weakly bound methods:
from weakref import ref as WeakRef

def _paramMinCountFunc(function):
    """Given a function, return pair (min,d) where min is minimum # of
    args required, and d is number of default arguments."""
    assert isfunction(function)
    (args, va, kwa, dflt) = getargspec(function)
    lenDef = len(dflt or ())
    lenArgs = len(args or ())

src/p/u/pubsub-HEAD/src/pubsub/pubsub1/pub.py pubsub(Download)

#---------------------------------------------------------------------------
 
# for function and method parameter counting:
from inspect import getargspec, ismethod, isfunction
# for weakly bound methods:
from weakref import ref as WeakRef

def _paramMinCountFunc(function):
    """Given a function, return pair (min,d) where min is minimum # of
    args required, and d is number of default arguments."""
    assert isfunction(function)
    (args, va, kwa, dflt) = getargspec(function)
    lenDef = len(dflt or ())
    lenArgs = len(args or ())

src/d/e/DecoratorTools-1.8/peak/util/decorators.py DecoratorTools(Download)

def name_and_spec(func):
    from inspect import formatargspec, getargspec
    funcname = func.__name__
    if funcname=='<lambda>':
        funcname = "anonymous"
    args, varargs, kwargs, defaults = getargspec(func)
    return funcname, formatargspec(args, varargs, kwargs)[1:-1]

def getbody(func):
    from inspect import getargspec
    args, varargs, kwargs, defaults = getargspec(func)
    return func(*[bomb] * len(args))

            return name+tuple.__repr__(self[1:])
 
        import inspect
        args, star, dstar, defaults = inspect.getargspec(func)
 
        d = dict(
            __new__ = __new__, __repr__ = __repr__, __doc__=func.__doc__,

    if func is None:
        return decorate_assignment(lambda f,k,v,o: synchronized(v))
 
    from inspect import getargspec
    first_arg = getargspec(func)[0][0]
 
    def wrap(__func):

src/e/d/Editra-0.5.72/src/extern/pubsub.py Editra(Download)

 
# for function and method parameter counting:
from types   import InstanceType
from inspect import getargspec, ismethod, isfunction
# for weakly bound methods:
from new     import instancemethod as InstanceMethod
from weakref import ref as WeakRef

def _paramMinCountFunc(function):
    """Given a function, return pair (min,d) where min is minimum # of
    args required, and d is number of default arguments."""
    assert isfunction(function)
    (args, va, kwa, dflt) = getargspec(function)
    lenDef = len(dflt or ())
    lenArgs = len(args or ())

src/b/a/badger-lib-HEAD/packages/Django/django/db/models/fields/subclassing.py badger-lib(Download)

to_python() and the other necessary methods and everything will work seamlessly.
"""
 
from inspect import getargspec
from warnings import warn
 
def call_with_connection(func):
    arg_names, varargs, varkwargs, defaults = getargspec(func)

def call_with_connection_and_prepared(func):
    arg_names, varargs, varkwargs, defaults = getargspec(func)
    updated = (
        ('connection' in arg_names or varkwargs) and
        ('prepared' in arg_names or varkwargs)
    )
    if not updated:

1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 Next