TypeError when calling super() in decorated method

[kdebrab]

Following code:

import attrs


def decorated(method):
    def wrapped(self, *args, **kwargs):
        return method(self, *args, **kwargs)

    return wrapped


@attrs.define()
class A:
    def f(self):
        pass


@attrs.define()
class B(A):
    @decorated
    def f(self):
        super().f()


B().f()

raises following error

TypeError: super(type, obj): obj must be an instance or subtype of type

If I use super(B, self), everything works just fine.

[hynek]

This problem is related to cell rewriting for slotted classes. Put simply we have to cheat a bit to make them work by rewriting method contents.

You get the same behavior with dataclasses:

@dataclasses.dataclass(slots=True)
@attrs.define
class C:
    @decorated
    def f(self):
        super().f()

TypeError: super(type, obj): obj must be an instance or subtype of type

Short fixes:

• don't use super that way
• disable slots (@attrs.define(slots=False))

Long-term fixes:

• open a bug on CPython for the dataclasses case and we'll steal it from them
• convince @Tinche to fix it for attrs right away ;)

I'm a bit dubious if it's actually possible to fix tho. :-/ Maybe, if functools.wraps is used and we follow the __wrapped__ attributes?

[kdebrab]

Thanks for the quick response! I'll use super(B, self) for now.

[liblaf]

I made a few experiments:

Environment:

• python: 3.12.10
• attrs: 25.3.0
• wrapt: 1.17.2

Same bug as above (click to expand)

from collections.abc import Callable

import attrs


def decorator[**P, T](func: Callable[P, T]) -> Callable[P, T]:
    def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
        print("wrapper()")
        return func(*args, **kwargs)

    return wrapper


@attrs.define
class A:
    def fun(self) -> None:
        print("A.fun()")


@attrs.define
class B(A):
    @decorator
    def fun(self) -> None:
        super().fun()
        print("B.fun()")


b = B()
b.fun()  # TypeError: super(type, obj): obj must be an instance or subtype of type

To my surprise, it works. (click to expand)

from collections.abc import Callable

import attrs


def decorator[**P, T](func: Callable[P, T]) -> Callable[P, T]:
    def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
        print("wrapper()")
        return func(*args, **kwargs)

    return wrapper


@attrs.define
class A:
    def fun(self) -> None:
        print("A.fun()")


@attrs.define
class B(A):
    @decorator
    def fun(self) -> None:
        super().fun()
        print("B.fun()")

    def fun_b(self) -> None:
        super().fun()  # ! won't work without this line
        print("B.fun_b()")


b = B()
b.fun()  # It works!

wrapt makes everything just fine (click to expand)

from typing import Any

import attrs
import wrapt


@wrapt.decorator
def decorator(wrapped, instance, args, kwargs) -> Any:
    print("decorator()")
    return wrapped(*args, **kwargs)


@attrs.define
class A:
    def fun(self) -> None:
        print("A.fun()")


@attrs.define
class B(A):
    @decorator
    def fun(self) -> None:
        super().fun()
        print("B.fun()")


b = B()
b.fun()  # It works!

Quoting from wrapt:

The wrapt module focuses very much on correctness. It therefore goes way beyond existing mechanisms such as functools.wraps() to ensure that decorators preserve introspectability, signatures, type checking abilities etc. The decorators that can be constructed using this module will work in far more scenarios than typical decorators and provide more predictable and consistent behavior.

I don't know how wrapt works. Hope this is useful for this issue.