def callable_wrapper(func): #{{{
if not _ab.callable(func):
raise TypeError('Argument is not callable')
def callwrapper(*args, **kwargs): #{{{
return func(*args, **kwargs)
# End def #}}}
return callwrapper
def _is_callable(self, object):
# #
"""Indicates if given method is a callable or a callable wrapper."""
return (
builtins.callable(object)
or builtins.isinstance(object, builtins.classmethod)
or builtins.isinstance(object, builtins.staticmethod)
)
def notifyParsingListeners(self, event):
for pl in self.parsingListeners:
if isinstance(pl, ParsingListener):
pl.onEvent(event)
else:
op = getattr(pl, "onEvent", event)
if callable(op):
op(event)
def notifyParsingListeners(self, event):
for pl in self.parsingListeners:
if isinstance(pl, ParsingListener):
pl.onEvent(event)
else:
op = getattr(pl, "onEvent", event)
if callable(op):
op(event)
def return_handler(advice):
'''
Supports classes, simple functions or methods as triggered \
return handler.
'''
if 'return' == advice['event']:
self.return_value = advice['callback'](
self.class_object, self.object,
self.__func__, self.arguments, self.keywords,
return_value)
if(builtins.hasattr(advice['callback'], 'aspect') and
builtins.callable(
builtins.getattr(advice['callback'], 'aspect'))):
self.return_value = self.return_value.aspect()
def jsgRun():
global gjsgi
global ghost
global gtoken
global gtask
global gtcount
method = gjsgi[gtask][0]
query = None
if callable(method):
jsgRunThrd(gtcount, gtoken, ghost, callback=method)
else:
query = gjsgi[gtask][1]
jsgRunThrd(gtcount, gtoken, ghost, method, query)
print 'End task!'
pass
def _inferir_columnas(self, lineas, func_validadora):
assert callable(func_validadora)
matriz = []
for linea in lineas:
matriz.append([func_validadora(celda) for celda in linea])
# https://stackoverflow.com/questions/4937491/\
# matrix-transpose-in-python
matriz_transpuesta = zip(*matriz)
resultado_validacion_por_columna = [
all(lista) for lista in matriz_transpuesta
]
return [
index
for index, value in enumerate(resultado_validacion_por_columna)
if value
]
def iscallable(obj): #{{{
if isclass(obj):
return False
return _ab.callable(obj)
fgetattr = fattribute = lambda attribute, *default: lambda object: getattr(object, attribute, *default)
# return a closure that always returns ``object``.
fconstant = fconst = falways = lambda object: lambda *a, **k: object
# a closure that returns it's argument always
fpassthru = fpass = fidentity = fid = lambda object: object
# a closure that returns a default value if its object is false-y
fdefault = lambda default: lambda object: object or default
# return the first, second, or third item of a box.
first, second, third, last = operator.itemgetter(0), operator.itemgetter(1), operator.itemgetter(2), operator.itemgetter(-1)
# return a closure that executes a list of functions one after another from left-to-right
fcompose = lambda *f: builtins.reduce(lambda f1, f2: lambda *a: f1(f2(*a)), builtins.reversed(f))
# return a closure that executes function ``f`` whilst discarding any extra arguments
fdiscard = lambda f: lambda *a, **k: f()
# return a closure that executes function ``crit`` and then returns/executes ``f`` or ``t`` based on whether or not it's successful.
fcondition = fcond = lambda crit: lambda t, f: \
lambda *a, **k: (t(*a, **k) if builtins.callable(t) else t) if crit(*a, **k) else (f(*a, **k) if builtins.callable(f) else f)
# return a closure that takes a list of functions to execute with the provided arguments
fmap = lambda *fa: lambda *a, **k: (f(*a, **k) for f in fa)
#lazy = lambda f, state={}: lambda *a, **k: state[(f, a, builtins.tuple(builtins.sorted(k.items())))] if (f, a, builtins.tuple(builtins.sorted(k.items()))) in state else state.setdefault((f, a, builtins.tuple(builtins.sorted(k.items()))), f(*a, **k))
#lazy = lambda f, *a, **k: lambda *ap, **kp: f(*(a+ap), **dict(k.items() + kp.items()))
# return a memoized closure that's lazy and only executes when evaluated
def flazy(f, *a, **k):
sortedtuple, state = fcompose(builtins.sorted, builtins.tuple), {}
def lazy(*ap, **kp):
A, K = a+ap, sortedtuple(k.items() + kp.items())
return state[(A, K)] if (A, K) in state else state.setdefault((A, K), f(*A, **builtins.dict(k.items()+kp.items())))
return lazy
fmemo = flazy
# return a closure with the function's arglist partially applied
fpartial = functools.partial
# return a closure that applies the provided arguments to the function ``f``.
