Question

Consider the following code:

class BaseClass(object):
    def _del_property(attr):
        """Abstract deller"""
        def del_attr(self):
            setattr(self, attr, None)
        return del_attr

    def _set_property(attr):
        """Abstract setter."""
        def set_attr(self, x):
            setattr(self, attr, x)            
        return set_attr

    def _get_property(attr):
        """Abstract getter"""
        def get_attr(self):
            getattr(self, attr)
        return get_attr

    _name = None
    name = property(fget=_get_property('_name'), fset=_set_property('_name'))


class Component(BaseClass):

    _material = None
    material = property(fget=_get_property('_material'), fset=_set_property('_material'), fdel=_del_property('_material'))

How come _get_property, _set_property and _del_property are not inherited?
How can it be achieved?

It should work for derived classes in the same source file, as well as for derived classes in a separate file, which import this source file with a

from filename import *

Answer 1

When creating a class, a new namespace is created. Python reads the block of code inside your class block and then passes the information to type (or the corresponding metaclass). In this case, python complains because when setting up the Component class, _get_property isn’t defined within that scope — perhaps BaseClass._get_property, but that probably won’t work like you want it to either.

One easy fix is to make those functions module level functions since the class namespace has access to the module namespace:

def _del_property(attr):
    """Abstract deller"""
    def del_attr(self):
        setattr(self, attr, None)
    return del_attr

def _set_property(attr):
    """Abstract setter."""
    def set_attr(self, x):
        setattr(self, attr, x)            
    return set_attr

def _get_property(attr):
    """Abstract getter"""
    def get_attr(self):
        getattr(self, attr)
    return get_attr


class BaseClass(object):

    _name = None
    name = property(fget=_get_property('_name'), fset=_set_property('_name'))


class Component(BaseClass):

    _material = None
    material = property(fget=_get_property('_material'), fset=_set_property('_material'), fdel=_del_property('_material'))

Perhaps it’s more instructive to look at the class while we’re creating it:

class BaseClass(object):

    def _del_property(attr):
        """Abstract deller"""
        def del_attr(self):
            setattr(self, attr, None)
        return del_attr

    print type(_del_property)
print type(BaseClass._del_property)

This will print:

<type 'function'>
<type 'instancemethod'>

So, you’re dealing with a regular function inside BaseClass, but it becomes an instancemethod after type does it’s magic.

---

Personally, I would just create a convenience function:

def property_api(name,fget=True,fset=True,fdel=True):
    return property(fget=_get_property(name) if fget else None,
                    fset=_set_property(name) if fset else None,
                    fdel=_del_property(name) if fdel else None)

Which you can then use. If you really want to, you could even put it on BaseClass as a staticmethod:

 class BaseClass(object):
      property_api = staticmethod(property_api)

Then your derived classes would look like:

 class DerivedClass(BaseClass):
      _material = None
      material = BaseClass.property_api('_material')