super() objects should be callable

[smurfix]

Bug report

Bug description:

IMHO, calling an inherited __call__ method should work without spelling it out.

class Foo:
    def __call__(self):
        print("A")
class Bar(Foo):
    def __call__(self):
        print("B")
        super()()  # TypeError: 'super' object is not callable
        super().__call__()  # works
Bar()()

CPython versions tested on:

3.14

Operating systems tested on:

Linux

[a12k]

This isn't a bug.

Super is a proxy object. For this one super().__call__() super is looking up Foo's (i.e., the parent's) __call__ explicitly, so that makes sense that it works. For this one super()() it is looking up type(super()).__call__) and __call__ doesn't exist on super() itself (only __call__ on the actual object Super is proxying exists). Actually this is consistent with all the dunder methods. len(super()) doesn't work even if the parent has __len__.

Some other languages allow this! But I think for Python, allowing super()() would require the cpython super type to implement maybe some sort of dynamic dispatch at runtime to lookup the next class in the Method Resolution Order. But I am no expert on that, so only speculating that I think it would be a major bit of work.

[johnslavik]

I was also initially surprised to learn that super() was intentionally designed this way!
What you observed is documented and correct behavior:

Note that super() is implemented as part of the binding process for explicit dotted attribute lookups such as super().__getitem__(name). It does so by implementing its own __getattribute__() method for searching classes in a predictable order that supports cooperative multiple inheritance. Accordingly, super() is undefined for implicit lookups using statements or operators such as super()[name].

It's likely that many people stumbled across this in the past, e.g. https://stackoverflow.com/questions/55992797/using-super-with-getitem-versus-subscript.

You could raise your idea at https://discuss.python.org/. I'd assume changing how super() works now on such a fundamental level would require a PEP.

Having said that, I think the only thing we could potentially do in the near future is provide more helpful errors for our users:

-super()()  # TypeError: 'super' object is not callable
+super()()  # TypeError: super() objects are not callable. Use super().__call__() instead.

-super()[42]  # TypeError: 'super' object is not subscriptable
+super()[42]  # TypeError: super() objects are not subscriptable. Use super().__getitem__() instead.

I will open a discussion at DPO about it.

Thank you for your interest in this :) I'll close this ticket for now, because there's nothing we can do about it at the very moment.