Unable to assign a function a method

[rowillia]

For example:

from typing import Any, Optional


class Foo(object):
    def __init__(self):
        # type: () -> None
        self.x = 0

    def get_x(self, a=None, b=None):
        # type: (Optional[int], Optional[int]) -> int
        return self.x + (a or 0) + (b or 0)


def get_x_patch(self, *args, **kwargs):
    #  type: (Foo, *Any, **Any) -> int
    return 42


Foo.get_x = get_x_patch

Results:

test_method_assignment.py:19: error: Cannot assign to a method

This assignment should be legal as any call to get_x will be able to call get_x_patch. It looks like 3ce8d6a explicitly disallowed all method assignments, but there's not a ton of context behind it.

I know monkeypatching is generally frowned upon, but is unfortunately a very popular part of Python. I can always mark those lines as ignored, but I'd rather be able to test that the patch is compatible with the underlying method with mypy.

[refi64]

I swear, this is a duplicate, but I can't find the issue # yet...

[rowillia]

@kirbyfan64 Yeah...I poked around and couldn't find anything. Happy to close this if it is!

[gvanrossum]

I think @sixolet might be interesting in this...

[JukkaL]

The mypy callable type representation isn't expressive enough to to check assignments to methods precisely. In particular, at least bound methods and unbound function objects should be treated differently. Consider this example:

class A:
    def f(self): pass
    def g(self): pass

def h(self): pass

A.f = h   # rvalue has one argument (unbound)
A().f()  # okay
A.f = A().g  # rvalue has no arguments (bound)
A().f()  # okay 

When we have value with an annotated callable type, such as Callable[[A], None], mypy can't decide whether this is a bound or unbound function method/function. Static methods and class methods might complicate this further.

I'm pretty sure this is already broken in other contexts, but we may want to resolve this eventually. Some random ideas:

1. Internally keep track whether a callable is bound so that we can do more precise checking. This would work for expressions with inferred types. For values explicitly annotated with a Callable type, the value of the flag would be unknown and these couldn't be used for monkey patching (unless the argument types are ...).
2. Like (1), but make some assumptions about annotated Callable types. Either assume that they are unbound, or optimistically assume that they have a compatible 'unboundedness' for any particular context. This is unsafe. This is basically how things work right now, though perhaps not consistently.
3. Add syntax for specifying callables that are always bound or unbound. We'd likely need three different variants: either bound or unbound (likely spelled just Callable), bound (for example, BoundMethod) and unbound (for example, UnboundCallable).

Option (3) doesn't seem worth the added complexity, to be honest, as it's always possible to fall back to Callable[..., X].

[gvanrossum]

So is the problem that when we see

class C:
    f = None  # type: Callable[[int, int], int]

we don't know whether that defines an instance variable or a class variable? Maybe we can use ClassVar (introduced by PEP 526 into the typing module)? E.g.

class C:
    f = None  # type: ClassVar[Callable[[int, int], int]]

and if ClassVar is not used assume f refers to an instance variable.

Of course initializations inside __init__ are unambiguous. And so are method definitions (with or without @staticmethod or @classmethod).

I do think mypy ought to be fully aware of bound and unbound methods.

But perhaps the original problem is due to something else? The immediate problem seems to be that we don't try to match *args, **kwds against a=None, b=None?

[ilevkivskyi]

Isn't this a duplicate of #708?

But maybe it makes sense to keep this open, since this issue contains some additional discussion.

[gvanrossum]

Not really -- IIUC this seems about monkey-patching a class, whereas #708 is about assigning to function attributes.

[Jym77]

A case where I keep running into that issue is when writing unit tests and trying to replace methods with MagicMock().

Typically, class Foo is defined and tested somewhere and class FooBar uses (an instance of) Foo, but in order to unit test FooBar I don't really need/want to make actual calls to Foo methods (which can either take a long time to compute, or require some setup (eg, networking) that isn't here for unit test, …) So, I heavily Mock() the methods which allow to test that the correct calls are issued and thus test FooBar.

It does feel bad to add a bunch a # type: ignore on all these mocks :-(

[JukkaL]

I prefer setattr over using # type: ignore. Mypy won't complain about it. This is something we could discuss in the common issues section in the docs.