Why is `list[Popen[str]] | list[Popen[bytes]] reduced to list[Popen[bytes]] and why to list[Popen[str]] in another case.

[Daraan]

I currently work with Popen objects and find a certain pyright behavior confusing, and would even call it a bug. In one of the examples below I get pure list[Popen[str]] or list[Popen[bytes]] types when I expect a union of some sort. Why is this the case?
Downstream working with elements of these objects is quite buggy.

Code sample in pyright playground

from __future__ import annotations
from subprocess import Popen
from typing import Sequence
from typing_extensions import reveal_type

pure_list: list[Popen[str]] | list[Popen[bytes]] = []
mixed_list: list[Popen[str] | Popen[bytes]] = []
str_seq_or_bytes_list: Sequence[Popen[str]] | list[Popen[bytes]] = []

reveal_type(mixed_list)  # list[Popen[str] | Popen[bytes]]
reveal_type(pure_list)  # list[Popen[bytes]]   ???
reveal_type(str_seq_or_bytes_list)  # list[Popen[str]]  ???

[erictraut]

The type of an object is established at the time it is constructed. The expression [] calls the list constructor — that is, it constructs a list[T] where T is some type that is determined by bidirectional type inference if a context is provided. In some cases like pure_list and str_seq_or_bytes_list in your example above, the context is ambiguous and T could be one of several types. In such a case, pyright chooses among them in a manner that is deterministic (produces the same results each time and in a way that is independent of union ordering).

If you want to avoid this, use an unambiguous context for bidirectional type inference or use an explicit type in a constructor call, like this:

pure_list: list[Popen[str]] | list[Popen[bytes]] = list[Popen[str]]()