attr.define seems to break __init_subclass__ (works with attr.s)

[sscherfke]

I like to use __init_subclass__ to implement simple plug-in systems, e.g.:

class OptionType:
    name: str
    __types__: dict[str, "OptionType"] = {}

    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        print(cls.name, cls)
        cls.__types__[cls.name] = cls

    @classmethod
    def instance_for(cls, name):
        return cls.__types__[name]()


class Int(OptionType):
    name: str = "int"


class IntRange(Int):
    name: str = "int-range"


print(OptionType.instance_for("int"))

When this is run, __init_subclass__ is run exactly once per class:

int <class '__main__.Int'>
int-range <class '__main__.IntRange'>
<__main__.Int object at 0x101462c70>

This also works with attr.s:

import attr


class OptionType:
    name: str
    __types__: dict[str, "OptionType"] = {}

    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        type_name = cls.name._default
        print(type_name, cls)
        cls.__types__[type_name] = cls

    @classmethod
    def instance_for(cls, name):
        return cls.__types__[name]()


@attr.s
class Int(OptionType):
    name: str = attr.ib("int")


@attr.s
class IntRange(Int):
    name: str = attr.ib("int-range")


print(OptionType.instance_for("int"))

int <class '__main__.Int'>
int-range <class '__main__.IntRange'>
Int(name='int')

However, when I use attr.define, everything falls appart:

import attr


_OPTION_TYPES: dict[str, "OptionType"] = {}


@attr.define
class OptionType:
    name: str

    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        type_name = attr.fields(cls).name.default
        print(type_name, cls)
        _OPTION_TYPES[type_name] = cls

    @classmethod
    def instance_for(cls, name):
        return _OPTION_TYPES[name]()


@attr.define
class Int(OptionType):
    name: str = "int"


@attr.define
class IntRange(Int):
    name: str = "int-range"


print(OptionType.instance_for("int"))

NOTHING <class '__main__.Int'>  # WHAT?
int <class '__main__.Int'>
int <class '__main__.IntRange'>  # ONOES! :-O
int-range <class '__main__.IntRange'>
IntRange(name='int')  # 😿

The main reason is, that __init_subclass__ is now called for every class in the inheritance hierarchy. That means that:

• the base class must also use attrs.define (or attr.fields(cls) (or cls.name.default) will break)
• __types__ must move out of the class or I’ll get a TypeError: 'member_descriptor' object does not support item assignment (because since it is typed, an attrs attribute is created for it).
• IntRange overrides the class for int, so OptionType.instance_for("int") now returns an IntRange() instead of an Int().

I have not yet time to dig deeper into it but I always had the impression that attr.define is just an alias for attr.s with nicer defaults but that seems not to be the case. 🤔

[Tinche]

It's probably __slots__ interfering with it. Try the attr.s example with slots=True.

[hynek]

of course, i'm open for another hack to make some feature work with slots ;)

[sscherfke]

@Tinche: It's probably __slots__ interfering with it. Try the attr.s example with slots=True.

The third example works if i set define(slots=False). If I also set auto_attribs=False, I can resemble the behavior of the second example. However, this only works with attr but not with the attrs import:

import attr


@attr.define(slots=False, auto_attribs=False)
class OptionType:
    name: str = attr.field()
    __types__: dict[str, "OptionType"] = {}

    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        type_name = attr.fields(cls).name.default
        print(type_name, cls)
        cls.__types__[type_name] = cls

    @classmethod
    def instance_for(cls, name):
        return cls.__types__[name]()


@attr.define(slots=False)
class Int(OptionType):
    name: str = "int"


@attr.define(slots=False)
class IntRange(Int):
    name: str = "int-range"


print(OptionType.instance_for("int"))

@hynek: of course, i'm open for another hack to make some feature work with slots ;)

That’s exactly the answer I was hoping for. Please notify me when you implemented this! 🤪

[sscherfke]

An improved documentation that stronger points out that slots are being used by default and what possible gotchas might look like would be a good-enough solution for me.

[hynek]

Where exactly would you like that to be?

It's currently prominently in the attrs.define docs:

[sscherfke]

The hint in braces is, compared to the amount and potential severness of the issues, not visible enough. I would use an admonition (attention or caution maybe) with a strong advice for users to acutally read the slotted classes gotchas.

[sscherfke]

Looks good, thanks :)