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 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``.