class AutoSuper(type):
    def __init__(cls, name, bases, dict):
        super(AutoSuper, cls).__init__(name, bases, dict)
        setattr(cls, "_%s__super" % name, super(cls))

class Base(object):
    __metaclass__ = AutoSuper

class A(Base):
    def f(self):
        print 'A.f'
        return None

class B(A):
    def f(self):
        print 'B.f'
        return self.__super.f()

class C(B):
    def f(self):
        print 'C.f'
        return self.__super.f()

...
def foo(self):
    return my.utils.super()

class A
{
  A(int) {}
};

class B: public A
{
typedef A MyParent;
public:
  B(int i): MyParent(i) {}
};

class C: public B
{
typedef B MyParent;
public:
  C(int i): MyParent(i) {}
};

# Для старых классов (не порожденных от object) пользуемся так:
#   make_super_for_classic_class(MyOld, Old)
# , установить после (!) описания класса MyOld

class Super(object):
    ''' По примеру http://www.python.org/download/releases/2.2/descrintro/#superexample '''
    def __init__(self, typ, obj):
        self.typ = typ
        self.obj = obj
    def __getattr__(self, attr):
        dct = self.typ.__dict__
        if attr in dct:
            x = dct[attr]
            if hasattr(x, "__get__"):
                # привязка метода x к объекту self.obj
                x = x.__get__(self.obj)
            return x
        raise AttributeError, attr

def make_super_for_classic_class(cls, parent_cls):
    def get_super_attr(obj):
        return Super(parent_cls, obj)
    # добавляем атрибут __super через setattr из-за скрытности первого
    # вне класса cls
    setattr(cls, "_%s__super" % cls.__name__, property(get_super_attr))

class AClassic:
    def func(self):
        return "A"

class BClassic(AClassic):
    def func(self):
        return self.__super.func() + "B"
make_super_for_classic_class(BClassic, AClassic)

class CClassic(BClassic):
    def func(self):
        return self.__super.func() + "C"
make_super_for_classic_class(CClassic, BClassic)

eq_('ABC', CClassic().func())