"""Support Eiffel-style preconditions and postconditions. | |
For example, | |
class C: | |
def m1(self, arg): | |
require arg > 0 | |
return whatever | |
ensure Result > arg | |
can be written (clumsily, I agree) as: | |
class C(Eiffel): | |
def m1(self, arg): | |
return whatever | |
def m1_pre(self, arg): | |
assert arg > 0 | |
def m1_post(self, Result, arg): | |
assert Result > arg | |
Pre- and post-conditions for a method, being implemented as methods | |
themselves, are inherited independently from the method. This gives | |
much of the same effect of Eiffel, where pre- and post-conditions are | |
inherited when a method is overridden by a derived class. However, | |
when a derived class in Python needs to extend a pre- or | |
post-condition, it must manually merge the base class' pre- or | |
post-condition with that defined in the derived class', for example: | |
class D(C): | |
def m1(self, arg): | |
return arg**2 | |
def m1_post(self, Result, arg): | |
C.m1_post(self, Result, arg) | |
assert Result < 100 | |
This gives derived classes more freedom but also more responsibility | |
than in Eiffel, where the compiler automatically takes care of this. | |
In Eiffel, pre-conditions combine using contravariance, meaning a | |
derived class can only make a pre-condition weaker; in Python, this is | |
up to the derived class. For example, a derived class that takes away | |
the requirement that arg > 0 could write: | |
def m1_pre(self, arg): | |
pass | |
but one could equally write a derived class that makes a stronger | |
requirement: | |
def m1_pre(self, arg): | |
require arg > 50 | |
It would be easy to modify the classes shown here so that pre- and | |
post-conditions can be disabled (separately, on a per-class basis). | |
A different design would have the pre- or post-condition testing | |
functions return true for success and false for failure. This would | |
make it possible to implement automatic combination of inherited | |
and new pre-/post-conditions. All this is left as an exercise to the | |
reader. | |
""" | |
from Meta import MetaClass, MetaHelper, MetaMethodWrapper | |
class EiffelMethodWrapper(MetaMethodWrapper): | |
def __init__(self, func, inst): | |
MetaMethodWrapper.__init__(self, func, inst) | |
# Note that the following causes recursive wrappers around | |
# the pre-/post-condition testing methods. These are harmless | |
# but inefficient; to avoid them, the lookup must be done | |
# using the class. | |
try: | |
self.pre = getattr(inst, self.__name__ + "_pre") | |
except AttributeError: | |
self.pre = None | |
try: | |
self.post = getattr(inst, self.__name__ + "_post") | |
except AttributeError: | |
self.post = None | |
def __call__(self, *args, **kw): | |
if self.pre: | |
apply(self.pre, args, kw) | |
Result = apply(self.func, (self.inst,) + args, kw) | |
if self.post: | |
apply(self.post, (Result,) + args, kw) | |
return Result | |
class EiffelHelper(MetaHelper): | |
__methodwrapper__ = EiffelMethodWrapper | |
class EiffelMetaClass(MetaClass): | |
__helper__ = EiffelHelper | |
Eiffel = EiffelMetaClass('Eiffel', (), {}) | |
def _test(): | |
class C(Eiffel): | |
def m1(self, arg): | |
return arg+1 | |
def m1_pre(self, arg): | |
assert arg > 0, "precondition for m1 failed" | |
def m1_post(self, Result, arg): | |
assert Result > arg | |
x = C() | |
x.m1(12) | |
## x.m1(-1) | |
if __name__ == '__main__': | |
_test() |