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
In Python, “frozen” means an object cannot be modified. For example, consider set and frozenset: >>> s = set((1, 2, 3)) >>> s {1, 2, 3} >>> s.add(4) >>> s {1, 2, 3, 4} >>> fs = frozenset((1, 2, 3)) >>> fs frozenset({1, 2, 3}) >>> fs.add(4) … AttributeError: ‘frozenset’ object has no attribute ‘add’ … Read more
Everyone seems to have missed the obvious solution. Using functools.update_wrapper: >>> import functools >>> class memoized(object): “””Decorator that caches a function’s return value each time it is called. If called later with the same arguments, the cached value is returned, and not re-evaluated. “”” def __init__(self, func): self.func = func self.cache = {} functools.update_wrapper(self, func) … Read more
If you are using Python 2.6 or later you could use a class decorator, perhaps something like this (warning: untested code). def class_decorator(cls): for name, method in cls.__dict__.iteritems(): if hasattr(method, “use_class”): # do something with the method and class print name, cls return cls def method_decorator(view): # mark the method as something that requires view’s … Read more
update for python version >= 3.10: staticmethod functions can be called from within class scope just fine (for more info see: python issue tracker, or “what’s new”, or here) for python version <= 3.9 continue reading staticmethod objects apparently have a __func__ attribute storing the original raw function (makes sense that they had to). So … Read more
std::function provides most of the building blocks for my proposed solution. Here is my proposed solution. #include <iostream> #include <functional> //——————————- // BEGIN decorator implementation //——————————- template <class> struct Decorator; template <class R, class… Args> struct Decorator<R(Args …)> { Decorator(std::function<R(Args …)> f) : f_(f) {} R operator()(Args … args) { std::cout << “Calling the decorated … Read more
Decorators usually return a wrapper function; just put your logic in the wrapper function after invoking the wrapped function. def audit_action(action): def decorator_func(func): def wrapper_func(*args, **kwargs): # Invoke the wrapped function first retval = func(*args, **kwargs) # Now do something here with retval and/or action print(‘In wrapper_func, handling action {!r} after wrapped function returned {!r}’.format(action, … Read more
The answer for a decorator has been given; it works at the function definition stage as requested. With Python 2.5+, you also have an option to do that at the function call stage using a context manager: from __future__ import with_statement # needed for 2.5 ≤ Python < 2.6 import contextlib, os @contextlib.contextmanager def remember_cwd(): … Read more
A mixin is apt when you’re adding some behavior to your class. e.g. the ability to enumerate in case of a collection type. You can mixin as many sets of behavior into your class as you want. Its a nice way to reuse common code ; you basically get a bunch of methods for free. … Read more
Decorators are much, much simpler and more limited — and therefore should be preferred whenever the desired effect can be achieved with either a metaclass or a class decorator. Anything you can do with a class decorator, you can of course do with a custom metaclass (just apply the functionality of the “decorator function”, i.e., … Read more