from System.ComponentModel import INotifyPropertyChanged, PropertyChangedEventArgs
    from Library.pyevent import make_event

    class Notify_property(property):
        ''' defines a notifiable property
        '''
        def __init__(self, getter):
            def newgetter(slf):
                #return None when the property does not exist yet
                try:
                    return getter(slf)
                except AttributeError:
                    return None
            super(Notify_property, self).__init__(newgetter)

        def setter(self, setter):
            def newsetter(slf, newvalue):
                # do not change value if the new value is the same
                # trigger PropertyChanged event when value changes
                oldvalue = self.fget(slf)
                if oldvalue != newvalue:
                    setter(slf, newvalue)
                    slf.OnPropertyChanged(setter.__name__)
            return property(
                fget=self.fget,
                fset=newsetter,
                fdel=self.fdel,
                doc=self.__doc__)

    class NotifyPropertyChangedBase(INotifyPropertyChanged):
        ''' The base of the MVVM view model
        Here the bound properties are added in addition with its
        handlers.
        '''
        # handlers which get fired on any change register here
        PropertyChanged = None
        ''' handlers that only get fired on their property change register here
        they are organized in a dictionary with the property name as key and
        a list of handlers as value
        '''
        _property_handlers = {}

        def __init__(self):
            ''' we create an event for the property changed event
            '''
            self.PropertyChanged, self._propertyChangedCaller = make_event()

        def add_PropertyChanged(self, value):
            ''' helper function to wrap the += behaviour
            '''
            self.PropertyChanged += value

        def remove_PropertyChanged(self, value):
            ''' helper function to wrap the -= behaviour
            '''
            self.PropertyChanged -= value

        def OnPropertyChanged(self, propertyName):
            ''' gets fired on an property changed event
            '''
            if self.PropertyChanged is not None:
                self._propertyChangedCaller(self, PropertyChangedEventArgs(propertyName))
            try:
                for property_handler in self._property_handlers[propertyName]:
                    property_handler(propertyName,PropertyChangedEventArgs(propertyName))
            except KeyError:
                pass

        def add_notifiable_property(self, notifiable_property):
            self.add_handled_property((notifiable_property,None))

        def add_notifiable_property_list(self, *symbols):
            for symbol in symbols:
                self.add_notifiable_property(symbol)

        def add_handled_property_list(self, *symbols):
            for symbol in symbols:
                self.add_handled_property(symbol)

        def add_handled_property(self, notifiable_property):
            symbol = notifiable_property[0]
            if notifiable_property[1] is not None:
                self._property_handlers[notifiable_property[0]] = notifiable_property[1]
            dnp ="""
    import sys
    sys.path.append(__file__)

    @Notify_property
    def {0}(self):
        return self._{0}

    @{0}.setter
    def {0}(self, value):
       self._{0} = value
   """.format(symbol)
            d = globals()
            exec dnp.strip() in d
            setattr(self.__class__, symbol, d[symbol])

add_notifiable_property('TestProperty')

add_handled_property((TestProperty,[handler1,handler2])

del self.TestProperty

undeletable attribute

delattr takes exactly 2 arguments 2 given

def remove_notifiable_property(self,propertyname):
    ''' removes a notifiable property
    '''
    self._property_handlers.pop(propertyname,None)
    exec"del self.{0}".format(propertyname)

@{0}.deleter
def {0}(self):
    del self._{0}

Derived calss has no attribute _TestProperty

class C(object):
    def __init__(self):
        pass#self._x = None

    @property
    def x(self):
       """I'm the 'x' property."""
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

    @x.deleter
    def x(self):
        del self._x

c = C()
print dir(c)
c.x = 'A'
print c.x
print dir(c)
del c.x
print dir (c)

exec"""self._{0} = None""".format(symbol)

delattr(self.__class__, 'TestProperty')

setattr(self.__class__, symbol, d[symbol])

>>> class A(object):
    class Property(object):
        def __get__(*args):
            print 'get:', args
        def __set__(*args):
            print 'set:', args
        def __delete__(*args):
            print 'del:', args
    p = Property()


>>> A.p
get: (<__main__.Property object at 0x7f3e16da4690>, None, <class '__main__.A'>)
>>> a = A()
>>> a.p
get: (<__main__.Property object at 0x7f3e16da4690>, <__main__.A object at 0x7f3e16da4910>, <class '__main__.A'>)
>>> a.p = 3
set: (<__main__.Property object at 0x7f3e16da4690>, <__main__.A object at 0x7f3e16da4910>, 3)
>>> del a.p
del: (<__main__.Property object at 0x7f3e16da4690>, <__main__.A object at 0x7f3e16da4910>)

>>> A.p = 2
>>> a.p
2

>>> A.p = A.Property()
>>> del A.p