Infer typed dict information when made explicit

[diego-pm]

I often want to annotate certain variables, initialized with a dictionary in-place, in order to have better IDE autocompletion and better type hints. I know the correct way to this with pyright is to define a typed dict:

class MyType(TypedDict):
    a: str
    b: list[int]
            
d: MyType = {'a': 'a', 'b': [1, 2, 3]}
# Equivalently
d = MyType(a='a', b=[1, 2, 3])

This is great, but many times I find these dictionaries are only declared once in the code, and the created type is not reused explicitly anywhere else.

I find this is too verbose, and wondered if pyright could do something to make this case less verbose.

I know that by simply declaring a dict like this: d = {'a': 'a', 'b': [1, 2, 3]}, pyright can not infere it is a typed dict because of the dict mutability. However, maybe it could be made something to tell the type checker that it should infer an in-place dictionary as a typed dict.

I am not sure if this is feasible, but I was thinking that when declaring a variable like this:

d: TypedDict = {'a': 'a', 'b': [1, 2, 3]}

pyright could use the bidirectional inference to infer the deatils of the typed dict. This is just an idea, maybe there is a better way to this this.

[erictraut]

This would require an update to the type standards. It's not something pyright would implement on its own. You could suggest it in the python/typing discussion forum if you would like to champion such a change. It would probably require a new PEP to be written and approved.

I think the proposal is problematic because type inference for dictionary values will likely be inaccurate in many cases. In your example above, would you expect the value type for 'a' to be Literal['a'] or LiteralString or str? For 'b' would you expect the type to be Sequence[int], list[int], or list[float]? Each type checker uses slightly different inference rules, so the resulting TypedDict type would be different from one type checker to the next.

[diego-pm]

Thanks for your reply! I believe it would be difficult to get a PEP about this specific thing.

Regarding how to infer the types of the dictionary fields, it should be searched the inference that fits most cases (probably str for 'a' and list[int] for 'b'). When the automatic inference is not good enough for one use case, people could always use the current approach of manually defining the typed dict schema.

Also, because this inference would be opt-in (only applies to dictionaries written in-place that are assigned to variables with type TypedDict), I think is fine if the different type checkers behave slightly different. Maybe, this is another reason to infer wider types.

Sorry if the nomenclature is not correct at all, I am not familiar with all of it.