pyright errors on incorrectly typed attrs classes, but only when used as a factory

[injust]

I ran into this seemingly inconsistent behaviour after incorrectly changing some attrs converters in agronholm/apscheduler#1014 (I forgot that the converters needed to account for a default value of None). However, pyright only errored when AsyncScheduler was used as an attrs factory. agronholm/apscheduler#1014 (comment) shows an example and the resulting error.

Minimal repro:

from attrs import Factory, define, field


def _int_to_int(value: int) -> int:
    return value


@define
class Foo1:
    # Incorrect because `None` is not an `int`
    one: int = field(default=None)


@define
class Foo2:
    # Incorrect because the converter does not take `None`
    one: int | None = field(default=None, converter=_int_to_int)


foo1 = Foo1()
foo2 = Foo2()


# pyright only errors when they are used as an attrs factory


@define
class Bar1:
    foo1: Foo1 = Factory(Foo1)


@define
class Bar2:
    foo2: Foo2 = Factory(Foo2)

./repro/bar.py
  ./repro/bar.py:30:26 - error: Argument of type "type[Foo1]" cannot be assigned to parameter "factory" of type "() -> _T@Factory" in function "Factory"
    Type "type[Foo1]" is not assignable to type "() -> Foo1"
      "None" is not assignable to "int"
      "None" is not assignable to "int" (reportArgumentType)
  ./repro/bar.py:35:26 - error: Argument of type "type[Foo2]" cannot be assigned to parameter "factory" of type "() -> _T@Factory" in function "Factory"
    Type "type[Foo2]" is not assignable to type "() -> Foo2"
      Type "int | None" is not assignable to type "int"
        "None" is not assignable to "int"
      Type "int | None" is not assignable to type "int"
        "None" is not assignable to "int" (reportArgumentType)
2 errors, 0 warnings, 0 notes

My environment:

apscheduler @ git+https://github.com/agronholm/apscheduler.git@8548e7f7c5af72c2888b9fdb524ad713556a2166
attrs==24.3.0
pyright==1.1.392.post0

[erictraut]

It's important to understand that pyright doesn't have any specific knowledge of attrs or its behaviors. Pyright performs its analysis based on the type information provided by the attrs library, which uses the dataclass_transform facility of the Python typing spec along with the recently-added support for converters.

Interestingly, if I switch your code to use the stdlib dataclass rather than attrs, both pyright and mypy detect that there's a mismatch in the default type.

from dataclasses import dataclass, field

@dataclass
class Foo:
    x: int = field(default=None) # Error: None is not assignable to int

This error is detected because of the way that the dataclasses.field function is defined. It's an overloaded function with three overloads, but we can focus only on the first overload which is the one that's applicable in this case. I've pasted it below for convenience. Note that the return type _T comes from the value passed to the default parameter.

    def field(
        *,
        default: _T,
        ...
    ) -> _T: ...

By contrast, attrs defines its field function differently. It uses four overloads, and here's the one that applies for your code sample, where you're passing None for the default value:

@overload
def field(
    *,
    default: None = ...,
    ...
) -> Any: ...

The return type for the call is evaluated as Any, so no error is detected. This is therefore a bug in the attrs library — specifically in the way it defines its field function. You might want to report this issue to the maintainers of attrs.

According to the attrs documentation, the default parameter has a default value of type NothingType, but the type annotations in the library don't match this documentation. If I change the library annotations to indicate a default of NothingType rather than None, then pyright detects the error in your sample code when no converter is specified. A second bug fix is needed in the attrs code for the overload that supports converters. The return type of the field call in this case should be based on the converter's return type.

So, I think pyright is working correctly here. Not surprisingly, mypy's behavior matches pyright's. Both pyright and mypy pass the type checker conformance tests for this functionality.

[injust]

Thanks for the very detailed explanation! I'll need to think this over, and I will also report the bugs to the attrs project.

The return type for the call is evaluated as Any, so no error is detected.

This makes sense, but I still don't understand how pyright comes up with the errors when using the Foo classes as an attrs factory. If the field() overload is returning Any, then how does pyright know that the default value of None cannot be assigned to int?

  ./repro/bar.py:30:26 - error: Argument of type "type[Foo1]" cannot be assigned to parameter "factory" of type "() -> _T@Factory" in function "Factory"
    Type "type[Foo1]" is not assignable to type "() -> Foo1"
      "None" is not assignable to "int"
      "None" is not assignable to "int" (reportArgumentType)

[erictraut]

The Factory function is defined as follows:

@overload
def Factory(factory: Callable[[], _T]) -> _T: ...

Note that its declared return type is not Any.