kuroko/test/testDecorators.krk
2021-01-03 18:26:55 +09:00

137 lines
3.5 KiB
Plaintext

def decorator(func):
def wrapper(butts):
print "I am a great decorated function that now needs an argument!", butts
func()
print "And this is after the function call."
print "Decorating!"
return wrapper
print "Decorator defined."
@decorator
def foo():
print "Bar"
print "Function with decorator defined."
foo("I am the argument")
print "Function with decorator called."
def __main__():
def decorator(func):
def wrapper(butts):
print "I am a great decorated function (within a function!) that now needs an argument!", butts
func()
print "And this is after the function call (in a function call!)"
print "Decorating!"
return wrapper
print "Decorator defined."
let i = 42
let l = [1,2,3]
@decorator
def foo():
print "Bar (the inner one)"
print "Function with decorator defined."
foo("I am in the inner wrapper.")
print "Function with decorator called."
print "I like the numbers", l
print "Calling main."
__main__()
def methodDecorator(func):
def wrappedMethod(instance, butts):
print "I need an extra arg:", butts
func(instance)
print "Done."
return wrappedMethod
class Foo():
def __init__(self):
self.foo = "bar"
print "I am an initializer."
def undecorated(self):
print "I am here."
print "self.foo =", self.foo
@methodDecorator
def decorated(self):
print "(decorated) self.foo = ", self.foo
let f = Foo()
print "Got an f:", f
f.undecorated()
print "Returned from f.undecorated()"
f.decorated("butts")
print "Returned from f.decorated()"
def decoratorWithArgument(decoratorArg):
def theActualDecorator(func):
print "I am decorating",func,"with this argument:",decoratorArg
def wrapped():
print "This wrapper captured this decorator arg:", decoratorArg
func()
return wrapped
return theActualDecorator
@decoratorWithArgument("foo")
def decoratedWithArgument():
print "I don't take any args of mine own, and nor does my wrapper."
decoratedWithArgument()
def methodDecoratorWithArguments(decoratorArgA, decoratorArgB):
def theActualDecorator(method):
print "I am decorating", method, "with these args:", decoratorArgA, decoratorArgB
def wrapped(instance, wrapperArg):
print "I captured these from the decorator:", decoratorArgA, decoratorArgB
print "I also take my own argument:", wrapperArg
method(instance,"and modify this one")
return wrapped
return theActualDecorator
class Bar():
@methodDecoratorWithArguments("foo","bar")
def superDecoratedMethod(self, arg):
print "I am method, so I can access", self, "and also my own argument which is now", arg
let b = Bar()
b.superDecoratedMethod("this arg goes to the wrapper")
def genericDecorator(func):
def wrapper(*args,**kwargs):
print "I am a generic wrapper, I will pass all of my args along."
func(*args,**kwargs)
print "And I am done."
return wrapper
@genericDecorator
def aMethod(with,args=None):
print "I got",with,"and",args
try:
aMethod()
except:
print exception.arg
aMethod("just the first")
aMethod("the first","and the second")
aMethod(args="hello",with="world")
try:
aMethod(foo="hello",with="bar")
except:
print exception.arg # unrecognized keyword arg, from inner method
aMethod(*[1,2])
try:
aMethod(*[1,2,3])
except:
print exception.arg # too many arguments