def ismethod(func):
try:
assert _getargspec(func).args[0] == 'self'
return True
except:
pass
return False
def getargspec(func):
try:
return func.argspec
except AttributeError:
try:
return _getargspec(func)
except TypeError:
raise TypeError("Sorry, this really is not a function, is it?")
def get_arg_spec(f):
arg_spec = _getargspec(f)
args = arg_spec.args
if arg_spec.varargs is not None:
args.append(arg_spec.varargs)
if arg_spec.keywords is not None:
args.append(arg_spec.keywords)
return Signature(args, {}, None)
def get_args(func):
"""Get a list of argument names for a function.
:param func: The function to inspect.
:return: A list of argument names.
:rtype: list
"""
return _getargspec(func).args
def getargspec(function):
# print 'hasattr im_func', hasattr(function, 'im_func')
if hasattr(function, 'im_func'):
# print('this is a special function : %s' % function)
# For methods or classmethods drop the first
# argument from the returned list because
# python supplies that automatically for us.
# Note that this differs from what
# inspect.getargspec() returns for methods.
# NB: We use im_func so we work with
# instancemethod objects also.
x = _getargspec(function.im_func)
new_args = x.args[1:]
spec = ArgSpec(args=new_args, varargs=x.varargs,
keywords=x.keywords, defaults=x.defaults)
return spec
# print 'calling normal %s' % function
return _getargspec(function)
def program_modules_with_function(typ, function_template):
""" list the programs implementing a given function
:param typ: which type of module it is (writer or reader)
:type typ: str
:param function_template: a function with the desired signature
:type function_template: function
"""
progs = []
for prog in pclass.values(par.Program):
module = import_program_module(prog, typ)
if hasattr(module, function_template.__name__):
function = getattr(module, function_template.__name__)
# make sure the signature matches the template
assert _getargspec(function) == _getargspec(function_template)
progs.append(prog)
return tuple(sorted(progs))
def __repr__(self):
try:
arg = _getargspec(self.__init__)
except TypeError:
argnames = ()
else:
argnames = arg.args[1:]
if arg.varargs is not None:
argnames.append(arg.varargs)
return "%s(%s)" % (
type(self).__name__,
", ".join("%s=%r" % (key, getattr(self, key)) for key in argnames if hasattr(self, key)),
)
def __repr__(self):
try:
arg = _getargspec(self.__init__)
except TypeError:
argnames = ()
else:
argnames = arg.args[1:]
if arg.varargs is not None:
argnames.append(arg.varargs)
return "%s(%s)" % (
type(self).__name__,
", ".join("%s=%r" % (key, getattr(self, key))
for key in argnames if hasattr(self, key)))
def __init__(self, func, returntype=_webtypes.null, argtypes=None):
if not _getargspec(func).args:
raise TypeError(
"{} func must take at least one argument (the"
" 'self' reference to its resource)".format(self.__class__.__name__)
)
self._argtypes = argtypes.copy() if argtypes else {}
self._func = func
self._resource = None
self._resource_class = None
self._response_content_funcs_own = {}
self._returntype = returntype
def outer(func):
# we use lifetime_func here so we don't shadow the global
# and get a 'referenced before assignment' error
if isinstance(lifetime, (int, float)):
lifetime_func = static_timeout(lifetime)
else:
lifetime_func = lifetime
argspec = _getargspec(func)
cacheable_keys = keys
if not keys:
cacheable_keys = argspec.args
@_wraps(func)
def inner(*args, **kwargs):
# as zip terminates as soon as one iterator is exausted we dont
# have to worry about the case where some args are specified and
# some use thier default value as the len(args) (ie the specified
# args) will cause automatic termination
args_mapping = zip(argspec.args, args)
cache_keys = []
for key, item in _chain(args_mapping, kwargs.items()):
if key in cacheable_keys:
cache_keys.append((key, item))
# lists are unhashable and cant be used as dict keys
cache_keys.sort()
cache_keys = tuple(val for key, val in cache_keys)
recalculate = False
cached = backend.get(cache_keys)
if cached:
expiry, output = cached
expire = lifetime_func(expiry)
if expire:
recalculate = True
else:
recalculate = True
if recalculate:
output = func(*args, **kwargs)
expiry = lifetime_func()
backend[cache_keys] = expiry, output
return output
return inner
def __init__(self, func):
self.__doc__ = func.__doc__
code = func.func_code
flags = code.co_flags
locals = code.co_nlocals
n = code.co_argcount
names = list(code.co_varnames)
has_args = has_kwargs = True
if not (flags & _CO_VARKEYWORDS):
# flags |= _CO_VARKEYWORDS
# locals += 1
# names.insert(n, '___fake_kwargs')
has_kwargs = False
if not (flags & _CO_VARARGS):
# flags |= _CO_VARARGS
# locals += 1
# names.insert(n, '___fake_args')
has_args = False
new_code = _code(n, locals, code.co_stacksize, flags,
code.co_code, code.co_consts, code.co_names,
tuple(names), code.co_filename, code.co_name,
code.co_firstlineno, code.co_lnotab)
self.__cache = {}
self.__func = _function(new_code, func.func_globals, func.func_name,
func.func_defaults, func.func_closure)
# self.__func.__fake_args = fake_args
# self.__func.__fake_kwargs = fake_kwargs
argspec = _getargspec(self.__func)
# args, varargs, varkw, defaults = argspec
if has_args:
self.__func.__maxargs = 666
else:
self.__func.__maxargs = len(argspec[0]) - 1
if argspec[3] == None:
defaults = []
defaultlen = 0
else:
defaults = argspec[3]
defaultlen = len(argspec[3])
self.__func.__minargs = len(argspec[0]) - defaultlen - 1
self.__func.__args = argspec[0]
self.__func.__defaults = defaults
self.__func.__has_args = has_args
self.__func.__has_kwargs = has_kwargs
def __init__(self, func):
self.__doc__ = func.__doc__
code = func.func_code
flags = code.co_flags
locals = code.co_nlocals
n = code.co_argcount
names = list(code.co_varnames)
has_args = has_kwargs = True
if not (flags & _CO_VARKEYWORDS):
# flags |= _CO_VARKEYWORDS
# locals += 1
# names.insert(n, '___fake_kwargs')
has_kwargs = False
if not (flags & _CO_VARARGS):
# flags |= _CO_VARARGS
# locals += 1
# names.insert(n, '___fake_args')
has_args = False
new_code = _code(n, locals, code.co_stacksize, flags, code.co_code,
code.co_consts, code.co_names, tuple(names),
code.co_filename, code.co_name, code.co_firstlineno,
code.co_lnotab)
self.__cache = {}
self.__func = _function(new_code, func.func_globals, func.func_name,
func.func_defaults, func.func_closure)
# self.__func.__fake_args = fake_args
# self.__func.__fake_kwargs = fake_kwargs
argspec = _getargspec(self.__func)
# args, varargs, varkw, defaults = argspec
if has_args:
self.__func.__maxargs = 666
else:
self.__func.__maxargs = len(argspec[0]) -1
if argspec[3] == None:
defaults = []
defaultlen = 0
else:
defaults = argspec[3]
defaultlen = len(argspec[3])
self.__func.__minargs = len(argspec[0]) - defaultlen - 1
self.__func.__args = argspec[0]
self.__func.__defaults = defaults
self.__func.__has_args = has_args
self.__func.__has_kwargs = has_kwargs
def __new__(cls, name, bases, dct):
newcls = super(cls, CallbackMeta).__new__(cls, name, bases, dct)
try:
argspec = _getargspec(dct["__init__"])
except (KeyError, TypeError):
pass
else:
args = argspec.args[1:]
if argspec.varargs:
_warn("varargs in %r" % cls)
if argspec.keywords:
_warn("keywords in %r" % cls)
for arg in args:
if arg in cls.registry:
_warn("ambiguous constructor argument %r in %r"
% (arg, cls))
else:
cls.registry[arg] = newcls
return newcls
def __new__(cls, name, bases, dct):
newcls = super(cls, CallbackMeta).__new__(cls, name, bases, dct)
try:
argspec = _getargspec(dct["__init__"])
except (KeyError, TypeError):
pass
else:
args = argspec.args[1:]
if argspec.varargs:
_warn("varargs in %r" % cls)
if argspec.keywords:
_warn("keywords in %r" % cls)
for arg in args:
if arg in cls.registry:
_warn("ambiguous constructor argument %r in %r" %
(arg, cls))
else:
cls.registry[arg] = newcls
return newcls
def getargspec(func):
if isinstance(func, PickleableStaticMethod):
return _getargspec(func.fn)
else:
return _getargspec(func)
def __init__(self, method):
self.argspec = _getargspec(method)
def getfuncargs(func):
# type: (Callable) -> List[str]
# pylint is too dumb to see that we do NOT use the deprecated variant. :-P
return _getargspec(func).args # pylint: disable=deprecated-method
def getfullargspec(fun, _fill=(None, ) * 3): # noqa
s = _getargspec(fun)
return FullArgSpec(*s + _fill)
def patched_get_argspec(func):
return ArgSpec(*inspect._getargspec(func))
def _has_argname(argname, function):
return argname in _getargspec(function).args
def getargspec(func):
if isinstance(func, PickleableStaticMethod):
return _getargspec(func.fn)
else:
return _getargspec(func)
def getfullargspec(fun, _fill=(None, ) * 3): # noqa
"""For compatibility with Python 3."""
s = _getargspec(fun)
return FullArgSpec(*s + _fill)
def required_argnames(self):
argspec = _getargspec(self.func)
# trim ``self`` off the beginning, defaultable args off the end
return argspec.args[1:][: -len(argspec.defaults or ())]
def kwargs_argname(self):
return _getargspec(self.func).keywords
def argdefaults(self):
argspec = _getargspec(self.func)
return dict(zip(reversed(argspec.args), reversed(argspec.defaults or ())))
def _get_kwarg_inputs(self):
# Trim off first parameter as it is reserved for workflow_parameters
return set(_getargspec(self.task_function).args[1:])
def getfullargspec(fun, _fill=(None, ) * 3): # noqa
s = _getargspec(fun)
return FullArgSpec(*s + _fill)
def getargspec(cls, target): return cls(_getargspec(target))
def _has_argname(argname, function):
return argname in _getargspec(function).args
def _get_kwarg_inputs(self):
# Trim off first two parameters as they are reserved for workflow_parameters and spark_context
return set(_getargspec(self.task_function).args[2:])
def getargspec(func):
return _getargspec(unwrap(func))
def patched_get_argspec(func):
return ArgSpec(*inspect._getargspec(func))
def __init__(self, method):
self.argspec = _getargspec(method)
def getargnames(func):
while hasattr(func, "__wrapped__"):
func = func.__wrapped__
spec = _getargspec(func)
return spec[:3]
def inspect_getfullargspec(func):
return FullArgSpec(*_getargspec(func)[0:4] + ([], None, {}))
def inspect_getfullargspec(func):
return FullArgSpec(*_getargspec(func)[0:4] + ([], None, {}))
def grad_named(fun, argname):
'''Takes gradients with respect to a named argument.
Doesn't work on *args or **kwargs.'''
arg_index = _getargspec(fun).args.index(argname)
return grad(fun, arg_index)
