Class with function fields incorrectly thinks first argument is self

[Dentosal]

This is a bug report.

Minimal repro

from dataclasses import dataclass
from typing import Callable

@dataclass
class Repro:
    fn: Callable[[int], str]

r = Repro(fn=repr)
assert "1" == r.fn(1)

Works correctly when dataclass is not used, i.e. when Repro is

class Repro:
    def __init__(self, fn: Callable[[int], str]) -> None:
        self.fn = fn

Actual behavior

repro.py:9: error: Invalid self argument "Repro" to attribute function "fn" with type "Callable[[int], str]"
repro.py:9: error: Too many arguments

When running with Python, works correctly. Doesn't throw any exceptions.

Expected behavior

Successful type check

Environment

Versions

Tested with two versions, 0.620 and current version from GitHub.

• Python 3.7.0
• mypy 0.620
• mypy 0.630+dev-a2ffde90635baf05e264f8d899f5705c52b27c2a

Mypy config

[mypy]
warn_redundant_casts = True
warn_unused_ignores = True
incremental = True

follow_imports = normal
ignore_missing_imports = True
disallow_untyped_calls = True
disallow_untyped_defs = True
check_untyped_defs = True
warn_return_any = True
warn_no_return = True
no_implicit_optional = True
strict_optional = True

[ilevkivskyi]

This is not something specific to dataclasses. There is a simpler repro that gives same errors:

class Repro:
    fn: Callable[[int], str]

r = Repro()
r.fn(1)

The problem is the same as in #708. I would however not close this as a duplicate, because this issue highlights another aspect of the problem.

[vim345]

I just came across the same issue. I guess a lot of people are going to face this issue very soon, as it's very easy to reproduce it using dataclasses.

[ilevkivskyi]

I guess this should be not hard to fix, mypy cares whether a callable was assigned in class (to match what Python does), so we should just tweak the Vars in plugin to pretend they were assigned on self. But we still need a volunteer who will fix this.

[ojii]

If someone needs a workaround, this works:

from dataclasses import dataclass
from typing import *

T = TypeVar("T")


@dataclass
class Box(Generic[T]):
    inner: T

    @property
    def unboxed(self) -> T:
        return self.inner


@dataclass
class Repro:
    fn: Box[Callable[[int], str]]


Repro(fn=Box(repr)).fn.unboxed(1)

[s-knibbs]

I've found that another workaround to this is to use a callback protocol instead of Callable

[rightfold]

When using NamedTuple instead of dataclass this problem does not arise.

[TH3CHARLie]

I volunteer to fix this and any guidances will be greatly helpful @ilevkivskyi

[ilevkivskyi]

@TH3CHARLie Fixing this in general may be tricky, but fixing just the dataclass case, should be easy. In any case, please go ahead!

[jordan-bucholtz]

I'm still running into this issue with dataclasses. @TH3CHARLie @ilevkivskyi Any resolution on this? 😃

versions

mypy 0.782
Python 3.8.7

[altendky]

@jordan-bucholtz i don't know if it makes any difference but fyi there is 0.800 (and 0.790 in between).

https://pypi.org/project/mypy/0.800/

[NeilGirdhar]

@altendky I'm using 0.800, and this is still broken for me.

[jp-larose]

Wondering if the solution is to somehow flag the Callable instance variable as a static method. Because that's essentially the intended use. Now, I'm not sure if the fix should be in mypy or in the typing library.

[asib]

I've found that another workaround to this is to use a callback protocol instead of Callable

@s-knibbs Could you make an example?

Probably too late for @nh2, but for anyone else who could use an example:

from dataclasses import dataclass
from typing import Callable
from typing_extensions import Protocol

class FunctionType(Protocol):
    def __call__(self, x: int) -> int:
        pass

@dataclass(frozen=True)
class A:
    fn: Callable[[int], int]
    
@dataclass(frozen=True)
class B:
    fn: FunctionType


A(fn=lambda x: x).fn(1) # Invalid self argument "A" to attribute function "fn" with type "Callable[[int], int]"
B(fn=lambda x: x).fn(1)

[eternal-sorrow]

I encoutered this with pathlib.Path('/my/path').stat().st_size. I got

Invalid self argument "stat_result" to attribute function "st_size" with type "Callable[[stat_result], int]"

This way I can't use any of the workarounds because I can't modify the standard stat_result type.