subclass with mandatory attribute cannot be created when the base class has a factory based one

[RonnyPfannschmidt]

failing example

import attr

def test_example():

    @attr.s
    class Base(object):
        attr = attr.ib(default=False)

    @attr.s
    class Sub(Base):
        needed = attr.ib()

[hynek]

This has been reported before and I’m not sure what to do about it. putting mandatory always before optionals? iow reordering?

[RonnyPfannschmidt]

they can always be given as keyword

the order should stay the same

it should be possible to give them as keyword instead of a positional argument

once inheritance is involved it seems sensible to go towards keywords in any case

basically all mandatory arguments after a optional one can be primary keyword based

[RonnyPfannschmidt]

btw, i do in fact use them as keywords, but putting in a default of None seems the wrong way

[hynek]

I kind of agree, but what’s better? having a sentinel and explode on it?

[RonnyPfannschmidt]

not quite sure what you mean by the sentinel

for the code in the example i posted i think that Sub(needed='foo') should work since all mandatory arguments where given

[hynek]

what you sketched it results in

def __init__(self, attr=False, needed):
    pass

which is a syntax error.

So we need some default value for needed here.

[RonnyPfannschmidt]

i see what you mean, in python3 its *, and valid, for python2 there is need for a workaround in form of a sentinel object and exploding then

[Tinche]

I accidentally opened up a duplicate of this.

My personal opinion™ is that we should just allow users to mark attributes as init='kwonly'. That will allow users to fix the problem themselves on Python 3 and consider upgrading on Python 2. 😽

Full example:

@attr.s
class A:
    a = attr.ib()
    b = attr.ib(init='kwonly', default=1)

    # __init__ signature is:
    def __init__(self, a, *, b=1):
        pass

@attr.s
class B(A):
    c = attr.ib()

    # __init__ signature is:
    def __init__(self, a, c, *, b=1):
        pass

Also, in the case of the error we have now, a helpful error message can direct users to use kwonly.

[jdmargulici]

I ran into this problem as well and I have a slightly different take on it that I wanted to submit. A more natural solution to me would be to write something like:

import attr

def test_example():

    @attr.s
    class Base(object):
        attr = attr.ib(default=False)

    @attr.s
    class Sub(Base):
        needed = attr.ib()
        attr = attr.ib(default=False)

At the cost of a very minor repetition of code, this lets the programmer explicitly control the order in which the attributes should appear for representation purposes or when converting to a tuple. However what I wrote obviously doesn't work in the current version of attr: because of the way inheritance is implemented, Sub receives two 'attr' attributes, which happens to break the __init__ method among other things. I do have a bit of beef with that and was both curious about why attributes don't get overridden in subclasses, and willing to do something about it -then I saw this issue and thought that would be a good starting point for my comment.

[traut]

how about this:

• add optional class-level var that defines the order of arguments (as list of strings?)
• if some required argument encountered in the child, fail with error, requesting explicit order of attributes specified?
• users can use required arguments in children but must provide order themselves explicitly