Estoy tratando de escribir una clase de controlador base cruda que hace lo siguiente: class BaseCrudController: model = “” field_validation = {} template_dir = “” @expose(self.template_dir) def new(self, *args, **kwargs) …. @validate(self.field_validation, error_handler=new) @expose() def post(self, *args, **kwargs): … Mi intención es que mis controladores amplíen esta clase base, establezcan el modelo, la validación de […]
tldnr: dada una función, ¿hay una manera de crear automáticamente un ArgumentParser a partir de su firma? Tengo un montón de funciones que me gustaría exponer a la línea de comandos. Así que básicamente, un módulo: def copy(foo, bar, baz): … def move(from, to): … def unlink(parrot, nomore=True): … if __name__ == ‘__main__’: argparse stuff […]
Aquí hay un ejemplo de lo que quiero decir: class MyDecorator(object): def __call__(self, func): # At which point would I be able to access the decorated method’s parent class’s instance? # In the below example, I would want to access from here: myinstance def wrapper(*args, **kwargs): return func(*args, **kwargs) return wrapper class SomeClass(object): ##self.name = […]
Quería imprimir el código fuente de my_func , que está envuelto por my_decorator : import inspect from functools import wraps def my_decorator(some_function): @wraps(some_function) def wrapper(): some_function() return wrapper @my_decorator def my_func(): print “supposed to return this instead!” return print inspect.getsource(my_func) Sin embargo, devuelve la fuente para el contenedor en su lugar: @wraps(some_function) def wrapper(): some_function() […]
¿Cómo puedo reemplazar *args y **kwargs con la firma real en la documentación de las funciones decoradas? Digamos que tengo el siguiente decorador y función decorada: import functools def mywrapper(func): @functools.wraps(func) def new_func(*args, **kwargs): print(‘Wrapping Ho!’) return func(*args, **kwargs) return new_func @mywrapper def myfunc(foo=42, bar=43): “””Obscure Addition :param foo: bar! :param bar: bla bla :return: […]
Quiero que las diferentes funciones sean ejecutables solo si el usuario conectado tiene el nivel de permiso requerido. Para hacer mi vida más compleja simplemente quiero usar decoradores. A continuación, bash configurar el permission atributo en las funciones “decoradas”, como se muestra a continuación. def permission(permission_required): def wrapper(func): def inner(*args, **kwargs): setattr(func, ‘permission_required’, permission_required) return […]
Digamos que tengo alguna clase base: class Task: def run(self): #override this! Ahora, quiero que otros subclasificaran Tarea y anulen el método run (): class MyTask(Task): def run(self): #successful override! Sin embargo, el problema es que hay una lógica que debe tener lugar antes y después del método run () de cada clase que subclases […]
Quiero importar una función: from random import randint y luego aplícale un decorador: @decorator randint Me preguntaba si había algo de azúcar sintáctica para esto (como lo que tengo arriba), o tengo que hacerlo de la siguiente manera: @decorator def randintWrapper(*args): return random.randint(*args)
Usando el decorador LRU Cache encontrado aquí: http://code.activestate.com/recipes/578078-py26-and-py30-backport-of-python-33s-lru-cache/ from lru_cache import lru_cache class Test: @lru_cache(maxsize=16) def cached_method(self, x): return x + 5 Puedo crear un método de clase decorado con esto, pero termina creando un caché global que se aplica a todas las instancias de la clase Test. Sin embargo, mi intención era crear un […]
Si estoy usando un módulo / clase sobre el que no tengo control, ¿cómo decoraría uno de los métodos? Entiendo que puedo: my_decorate_method(target_method)() pero estoy buscando que esto suceda dondequiera que se target_method sin tener que hacer una búsqueda / reemplazo. ¿Es incluso posible?