Created attachment 348 [details]
Minimal example to reproduce broken super mechanism

The same applies for any Python object, example:

class A (object):
    def __init__(self):
        print "A"

class B (object):
    def __init__(self):
        print "B"


class C (A, B):
    def __init__(self):
        super(C, self).__init__()
        print "C"

c = C()


This will print:

A
C

And B is left uninitialized, so it's seems to be a normal Python behavior, you
need to call both parent constructor manually.

You example is misleading, when you want to use the super mechanism you have to
call super on each node in the diamond shaped inheritance tree:


class A (object):
    def __init__(self):
        super(A, self).__init__()
        print "A"

class B (object):
    def __init__(self):
        super(B, self).__init__()
        print "B"

class C (A, B):
    def __init__(self):
        super(C, self).__init__()
        print "C"

c = C()

This will print:

B
A
C


I suspect PySide is either missing some nodes or is using the older direct call
approach: Base.__init__(self, ...). Which leads to some serious problems in the
case of multiple inheritance. Look at the following:



class Base(object):
    def __init__(self):
        object.__init__(self)
        print 'Init Base'

class A (Base):
    def __init__(self):
        Base.__init__(self)
        print "A"

class B (Base):
    def __init__(self):
        Base.__init__(self)
        print "B"

class C (A, B):
    def __init__(self):
        A.__init__(self)
        B.__init__(self)
        print "C"

c = C()


This will print:

Init Base
A
Init Base
B
C

In contrast to that using super would print:

Init Base
B
A
C



class Base(object):
    def __init__(self):
        super(Base, self).__init__()
        print 'Init Base'

class A (Base):
    def __init__(self):
        super(A, self).__init__()
        print "A"

class B (Base):
    def __init__(self):
        super(B, self).__init__()
        print "B"

class C (A, B):
    def __init__(self):
        super(C, self).__init__()
        print "C"

c = C()

(In reply to comment #3)
> You example is misleading, when you want to use the super mechanism you have to
> call super on each node in the diamond shaped inheritance tree:
> 
> 
> class A (object):
>     def __init__(self):
>         super(A, self).__init__()
>         print "A"
> 
> class B (object):
>     def __init__(self):
>         super(B, self).__init__()
>         print "B"
> 
> class C (A, B):
>     def __init__(self):
>         super(C, self).__init__()
>         print "C"
> 
> c = C()
> 
> This will print:
> 
> B
> A
> C

What if A anb B has no default constructors? e.g. A constructor receives a
string object and B constructor another completely different object?

e.g.:

class Foo (object):
    def bar(self):
        return 1

class A (object):
    def __init__(self, number):
        super(A, self).__init__()
        self.n = number + 1
        print "A"

class B (object):
    def __init__(self, foo):
        super(B, self).__init__()
        self.foo = foo.bar()
        print "B"

How the C super call should be made?

> I suspect PySide is either missing some nodes or is using the older direct call
> approach: Base.__init__(self, ...). Which leads to some serious problems in the
> case of multiple inheritance. Look at the following:
> 
> 
> 
> class Base(object):
>     def __init__(self):
>         object.__init__(self)
>         print 'Init Base'
> 
> class A (Base):
>     def __init__(self):
>         Base.__init__(self)
>         print "A"
> 
> class B (Base):
>     def __init__(self):
>         Base.__init__(self)
>         print "B"
> 
> class C (A, B):
>     def __init__(self):
>         A.__init__(self)
>         B.__init__(self)
>         print "C"
> 
> c = C()
> 
> 
> This will print:
> 
> Init Base
> A
> Init Base
> B
> C
> 
> In contrast to that using super would print:
> 
> Init Base
> B
> A
> C
> 
> 
> 
> class Base(object):
>     def __init__(self):
>         super(Base, self).__init__()
>         print 'Init Base'
> 
> class A (Base):
>     def __init__(self):
>         super(A, self).__init__()
>         print "A"
> 
> class B (Base):
>     def __init__(self):
>         super(B, self).__init__()
>         print "B"
> 
> class C (A, B):
>     def __init__(self):
>         super(C, self).__init__()
>         print "C"
> 
> c = C()

Good point, with arguments it starts to get tricky.

I would implement your example as following:


class Foo(object):
    def bar(self):
        return 1

class A(object):
    def __init__(self, number, **kwargs):
        super(A, self).__init__(**kwargs)
        self.n = number + 1
        print "A"

class B(object):
    def __init__(self, foo, **kwargs):
        super(B, self).__init__(**kwargs)
        self.foo = foo.bar()
        print "B"

class C(A, B):
    def __init__(self, number, foo, **kwargs):
        kwargs.update({'number': number, 'foo': foo})
        super(C, self).__init__(**kwargs)
        print "C"

c = C(2, Foo())
print c.n, c.foo

That will print:

B
A
C
3 1

Instead of:


    kwargs.update({'number': number, 'foo': foo})
    super(C, self).__init__(**kwargs)

You could also do simply:

    super(C, self).__init__(number=number, foo=foo, **kwargs)

(In reply to comment #6)
> Instead of:
> 
> 
>     kwargs.update({'number': number, 'foo': foo})
>     super(C, self).__init__(**kwargs)
> 
> You could also do simply:
> 
>     super(C, self).__init__(number=number, foo=foo, **kwargs)

More problems rising up...

Not all class constructors on generated bindings supports keyword arguments,
and even so we can't guarantee that they all have different names, so how to
implement C inheriting from A and B bellow?

class A(object):
    def __init__(self, arg, **kwargs):
        super(A, self).__init__(**kwargs)
        self.n = arg + 1
        print "A"

class B(object):
    def __init__(self, arg, **kwargs):
        super(B, self).__init__(**kwargs)
        self.foo = arg.bar()
        print "B"

I have to admit the whole topic opens many questions and I currently don't have
a good concept to implement __init__ with the super mechanism.

Although having clear advantages in diamond shaped inheritance trees the whole
super concept seems to be not very widespread in the Python community. And our
discussion shows that it is absolutely understandable why most ignore it and
here Python has failed to comply "There should be one-- and preferably only one
--obvious way to do it." in my opinion.

However thanks Hugo for the open discussion.

After this very useful discussion I'm marking this bug as wontfix as we can't
achieve a good solution to the problem due to Python deficiencies related to
the super mechanism and base classes with different constructor arguments
without names.

Regards

Release PySide 1.0.6