Zy Filemanager

📁 File Browser

Name	Size	Permissions	Actions
📄 Eiffel.py (3,468 bytes)	3.39 KB	0644	✍️ ⬇️ 🗑️
📄 Eiffel.pyc (4,632 bytes)	4.52 KB	0644	✍️ ⬇️ 🗑️
📄 Eiffel.pyo (4,530 bytes)	4.42 KB	0644	✍️ ⬇️ 🗑️
📄 Enum.py (4,419 bytes)	4.32 KB	0644	✍️ ⬇️ 🗑️
📄 Enum.pyc (6,179 bytes)	6.03 KB	0644	✍️ ⬇️ 🗑️
📄 Enum.pyo (6,179 bytes)	6.03 KB	0644	✍️ ⬇️ 🗑️
📄 Meta.py (2,933 bytes)	2.86 KB	0644	✍️ ⬇️ 🗑️
📄 Meta.pyc (4,579 bytes)	4.47 KB	0644	✍️ ⬇️ 🗑️
📄 Meta.pyo (4,579 bytes)	4.47 KB	0644	✍️ ⬇️ 🗑️
📄 Simple.py (1,192 bytes)	1.16 KB	0644	✍️ ⬇️ 🗑️
📄 Simple.pyc (2,746 bytes)	2.68 KB	0644	✍️ ⬇️ 🗑️
📄 Simple.pyo (2,746 bytes)	2.68 KB	0644	✍️ ⬇️ 🗑️
📄 Synch.py (7,938 bytes)	7.75 KB	0644	✍️ ⬇️ 🗑️
📄 Synch.pyc (8,462 bytes)	8.26 KB	0644	✍️ ⬇️ 🗑️
📄 Synch.pyo (8,314 bytes)	8.12 KB	0644	✍️ ⬇️ 🗑️
📄 Trace.py (4,133 bytes)	4.04 KB	0644	✍️ ⬇️ 🗑️
📄 Trace.pyc (6,173 bytes)	6.03 KB	0644	✍️ ⬇️ 🗑️
📄 Trace.pyo (6,173 bytes)	6.03 KB	0644	✍️ ⬇️ 🗑️
📝 index.html (20,573 bytes)	20.09 KB	0644	✍️ ⬇️ 🗑️
📄 meta-vladimir.txt (11,527 bytes)	11.26 KB	0644	✍️ ⬇️ 🗑️

✍️ Editing: Eiffel.py

            File: /lib64/python2.7/Demo/metaclasses/Eiffel.py

            Size: 3.39 KB | 
            Last Modified: 2020-04-20 04:13:39        

"""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()

↩️ Back

Zy Filemanager

📁 File Browser

📤 Upload Files

Single File

Multiple Files

ZIP Extract

➕ Create New

New Folder

New File

✍️ Editing: Eiffel.py

Backup Management