ÿØÿà JFIF    ÿÛ „ ( %!1!%*+...983,7(-.- lib64/python2.7/Demo/metaclasses/Eiffel.py000064400000006614152351776530014215 0ustar00"""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() lib64/python2.7/Demo/newmetaclasses/Eiffel.py000064400000007201152365021550014706 0ustar00"""Support Eiffel-style preconditions and postconditions.""" from types import FunctionType as function class EiffelBaseMetaClass(type): def __new__(meta, name, bases, dict): meta.convert_methods(dict) return super(EiffelBaseMetaClass, meta).__new__(meta, name, bases, dict) @classmethod def convert_methods(cls, dict): """Replace functions in dict with EiffelMethod wrappers. The dict is modified in place. If a method ends in _pre or _post, it is removed from the dict regardless of whether there is a corresponding method. """ # find methods with pre or post conditions methods = [] for k, v in dict.iteritems(): if k.endswith('_pre') or k.endswith('_post'): assert isinstance(v, function) elif isinstance(v, function): methods.append(k) for m in methods: pre = dict.get("%s_pre" % m) post = dict.get("%s_post" % m) if pre or post: dict[m] = cls.make_eiffel_method(dict[m], pre, post) class EiffelMetaClass1(EiffelBaseMetaClass): # an implementation of the "eiffel" meta class that uses nested functions @staticmethod def make_eiffel_method(func, pre, post): def method(self, *args, **kwargs): if pre: pre(self, *args, **kwargs) x = func(self, *args, **kwargs) if post: post(self, x, *args, **kwargs) return x if func.__doc__: method.__doc__ = func.__doc__ return method class EiffelMethodWrapper: def __init__(self, inst, descr): self._inst = inst self._descr = descr def __call__(self, *args, **kwargs): return self._descr.callmethod(self._inst, args, kwargs) class EiffelDescriptor(object): def __init__(self, func, pre, post): self._func = func self._pre = pre self._post = post self.__name__ = func.__name__ self.__doc__ = func.__doc__ def __get__(self, obj, cls): return EiffelMethodWrapper(obj, self) def callmethod(self, inst, args, kwargs): if self._pre: self._pre(inst, *args, **kwargs) x = self._func(inst, *args, **kwargs) if self._post: self._post(inst, x, *args, **kwargs) return x class EiffelMetaClass2(EiffelBaseMetaClass): # an implementation of the "eiffel" meta class that uses descriptors make_eiffel_method = EiffelDescriptor def _test(metaclass): class Eiffel: __metaclass__ = metaclass class Test(Eiffel): def m(self, arg): """Make it a little larger""" return arg + 1 def m2(self, arg): """Make it a little larger""" return arg + 1 def m2_pre(self, arg): assert arg > 0 def m2_post(self, result, arg): assert result > arg class Sub(Test): def m2(self, arg): return arg**2 def m2_post(self, Result, arg): super(Sub, self).m2_post(Result, arg) assert Result < 100 t = Test() t.m(1) t.m2(1) try: t.m2(0) except AssertionError: pass else: assert False s = Sub() try: s.m2(1) except AssertionError: pass # result == arg else: assert False try: s.m2(10) except AssertionError: pass # result == 100 else: assert False s.m2(5) if __name__ == "__main__": _test(EiffelMetaClass1) _test(EiffelMetaClass2)