Error when annotating a function that instantiates TypedDicts

[RomeoDespres]

I have a function f which takes as argument a TypedDict class, and returns an instance of this class.

I've tried the following implementation using TypeVar. However when passing around the result of f, mypy complains about it not having the correct type. I've narrowed it down to the snippet below:

from typing import Type, TypeVar, TypedDict


T = TypeVar("T")


def f(cls: Type[T]) -> T:
    return cls()


class Foo(TypedDict):
    pass


f_foo: Foo = f(Foo)

reveal_type(f(Foo))

The output of mypy is then:

test.py:15: error: Incompatible types in assignment (expression has type "Foo", variable has type "Foo")
test.py:17: note: Revealed type is "test.Foo*"

Why is the type of f(Foo) test.Foo* instead of TypedDict('test.Foo', {})?

Environment:

• Mypy version used: 0.931
• Mypy command-line flags: None
• Mypy configuration options from mypy.ini (and other config files): None
• Python version used: 3.9.2
• Operating system and version: Windows 10 21H1

[JelleZijlstra]

A TypedDict is not a valid Type. You need something like #9773.

As a workaround, you can probably annotate as Callable[[], T] instead.

[RomeoDespres]

Thanks @JelleZijlstra

Changing the annotation to:

def f(cls: Callable[[], T]) -> T:
    return cls()

does not affect mypy output, which is still:

test.py:15: error: Incompatible types in assignment (expression has type "Foo", variable has type "Foo")
test.py:17: note: Revealed type is "test.Foo*"

Is this still not a bug?

[maxfischer2781]

I think the confusing (broken?) part is that MyPy figures out the return type is a test.Foo* but not that this is equal to TypedDict('test.Foo', {}). I would expect it to either reject substitution completely, or treat both "ends" as equivalent.

A TypedDict is not a valid Type.

Would it be feasible to report an error when encountering Type[SomeTypedDict]? Does the added layer of a TypeVar complicate this situation significantly?

[JelleZijlstra]

@RomeoDespres that does feel like a bug; TypedDict should be compatible with Callable.

@maxfischer2781 yes I think the error message here isn't great. We should improve this.

[etienne-lebrun]

I worked around this issue by passing in a lambda :f(lambda:Foo())

[erictraut]

It appears that this was fixed in mypy 0.981. The error no longer occurs.

[advl]

Was looking for a way to achieve a mapping with a TypedDict in the **kwargs of a function. For those looking for a solution, PEP692 provides the answer. Use Unpack

from typing import TypedDict, Unpack                                                                                                                                             
                                                                             
class CommandOptions(TypedDict):                                             
    """                                                                      
    TypedDict for the options of the command.                                
    """                                                                      
                                                                             
    group_name: str                                                          
    stage_name: str                                                          
    database_prefix: str                                                     
                                                                             
                                                                             
class Command(BaseCommand):                                                                                                                                                                                            
    def handle(self, **options: Unpack[CommandOptions]) -> None: