Ethan Furman wrote:
On 11/06/2014 10:59 PM, dieter wrote:
A possibility to get the original approach implemented looks like:
make "__call__" a descriptor on the class which looks up the real
method on the instance.
This still wouldn't get the signatrue correct, though.
Why not? Once the descriptor is resolved, you get the final
instance method - with the correct signature.
Hmmm... well, it wouldn't be correct on a class lookup, but, yeah, it
would be correct for an instance lookup -- and maybe that's good enough
for the OP.
Seems to depend on how you get hold of the object you're
inspecting the signature of. I did an experiment:
class C(object):
@property
def __call__(self):
return self.call
def f(x, y):
print("Called f with %s, %s" % (x, y))
c = C()
c.call = f
c(17, 42)
prints:
Called f with 17, 42
This works too:
import inspect
print(inspect.getargspec(c.__call__))
prints:
ArgSpec(args=['x', 'y'], varargs=None, keywords=None, defaults=None)
But
print(inspect.getargspec(c))
doesn't work:
TypeError: <__main__.C object at 0x479250> is not a Python function
(BTW, I'm actually surprised that this technique makes c callable.
There must be more going on that just "look up __call__ in the class
object", because evaluating C.__call__ just returns the descriptor
and doesn't invoking the descriptor mechanism.)
--
Greg
--
https://mail.python.org/mailman/listinfo/python-list
