Reliably Positional-Only `self` in `__call__`

The C version of CallableObjectProxy.__call__ already has self be a positional-only argument, but the Python version doesn’t.

Here’s a good way to fix that which works on all old Python versions that wrapt still supports:

 class CallableObjectProxy(ObjectProxy):
-    def __call__(self, *args, **kwargs):
+    def __call__(*args, **kwargs):
+        def __call__(self, *args):
+            return self, args
+        self, args = __call__(*args)
         return self.__wrapped__(*args, **kwargs)

(Using a nested function with the same name is a good way to get a native exception with the same message that you normally would if you go out of your way to call CallableObjectProxy.__call__ directly.)

[GrahamDumpleton]

It will take me a while to read and digest that wall of text. Am not in the right frame of mind right now so haven’t even tried to read it through.

One point I will make is that there are various cases where things implemented as pure Python don’t work the same as when done using C APIs. That is just how CPython is. I am not going out of my way to make them different, it just happens when you do things in the normally accepted ways using the respective APIs, they will not behave the same or it can’t be done in the same way, which in the case of trying to support both is always a problem as far as uniformity. I have tried very hard to make them work the same, but there are still some cases where it isn’t possible because the C API lacks features, or has strange limitations.

Anyway, I have perhaps not been understanding what the problem is you are trying to solve here, which is why was asking for the actual use cases. On first quick glance it seemed to be you were trying to side step binding semantics which is always a red flag for something being done wrong.

So I will look at this some more, I just will not get to it immediately.

[mentalisttraceur]

Actually I want to take emphasis off CallableObjectProxy.__call__ and refocus onto stuff like FunctionWrapper.__call__.

CallableObjectProxy.__call__ is so simple that I can trivially make sure my code polyfills the desired behavior on top of the pure-Python version:

from wrapt import CallableObjectProxy as _CallableObjectProxy

...

try:
    _CallableObjectProxy(lambda self: None)(self=None)
except TypeError:
    class _CallableObjectProxy(_CallableObjectProxy):
        def __call__(self, /, *args, **kwargs):
            return self.__wrapped__(*args, **kwargs)

But FunctionWrapper.__call__ has much more logic, and seems like the kind of problem where consumer code can’t self-provide a fix without duplicating all of __call__.