It seems py.test doesn’t use the test fixtures when evaluating the expression for skipif. By your example, test_ios is actually successful because it is comparing the function platform found in the module’s namespace to the “ios” string, which evaluates to False hence the test is executed and succeeds. If pytest was inserting the fixture for … Read more
Decorators are simply callables that return a replacement, optionally the same function, a wrapper, or something completely different. As such, you could create a conditional decorator: def conditional_decorator(dec, condition): def decorator(func): if not condition: # Return the function unchanged, not decorated. return func return dec(func) return decorator Now you can use it like this: @conditional_decorator(timeit, … Read more
The important thing to remember about decorators is that a decorator is a function that takes a function as an argument, and returns yet another function. The returned value – yet another function – is what will be called when the name of the original function is invoked. This model can be very simple: def … Read more
You should return the wrapper function itself, not its result: def tsfunc(func): def wrappedFunc(): print ‘%s() called’ % func.__name__ return func() return wrappedFunc # Do not call the function, return a reference instead Decorators replace the decorated item with the return value of the decorator: @tsfunc def foo(): # …. is equivalent to: def foo(): … Read more
Take a good look at this enormous answer/novel. It’s one of the best explanations I’ve come across. The shortest explanation that I can give is that decorators wrap your function in another function that returns a function. This code, for example: @decorate def foo(a): print a would be equivalent to this code if you remove … Read more
From the Decorators for Functions and Methods: Python 2 def accepts(*types): def check_accepts(f): assert len(types) == f.func_code.co_argcount def new_f(*args, **kwds): for (a, t) in zip(args, types): assert isinstance(a, t), \ “arg %r does not match %s” % (a,t) return f(*args, **kwds) new_f.func_name = f.func_name return new_f return check_accepts Python 3 In Python 3 func_code has … Read more
You can’t. Scoped names (closures) are determined at compile time, you cannot add more at runtime. The best you can hope to achieve is to add global names, using the function’s own global namespace: def decorator_factory(value): def msg_decorator(f): def inner_dec(*args, **kwargs): g = f.__globals__ # use f.func_globals for py < 2.6 sentinel = object() oldvalue … Read more
Other examples would be validation/filtering of the set attributes (forcing them to be in bounds or acceptable) and lazy evaluation of complex or rapidly changing terms. Complex calculation hidden behind an attribute: class PDB_Calculator(object): … @property def protein_folding_angle(self): # number crunching, remote server calls, etc # all results in an angle set in ‘some_angle’ # … Read more
Decorators wrap the function they are decorating. So make_bold decorated the result of the make_italic decorator, which decorated the hello function. The @decorator syntax is really just syntactic sugar; the following: @decorator def decorated_function(): # … is really executed as: def decorated_function(): # … decorated_function = decorator(decorated_function) replacing the original decorated_function object with whatever decorator() … Read more
If you are not into long explanations, see Paolo Bergantino’s answer. Decorator Basics Python’s functions are objects To understand decorators, you must first understand that functions are objects in Python. This has important consequences. Let’s see why with a simple example : def shout(word=”yes”): return word.capitalize()+”!” print(shout()) # outputs : ‘Yes!’ # As an object, … Read more