dict[int, bool] | dict[str, bool] being interpreted as dict[int | str, bool]

[mvanderlee]

Dict comprehension from dict[int, bool] | dict[str, bool] results in dict[int | str, bool] which is incorrect. This is likely due to the fact that a the key itself would be int | str and that is used as the source of truth.

I got it working by using generics, but when trying to use recursion it fell apart again. I think because it's not treating the recursive K as a new type and instead keeps the parent type? Type "Mapping[str, set_type | map_type | bool]" is not assignable to type "Mapping[int, map_type | set_type | bool] | set[int]"

from collections.abc import Mapping
from typing import TypeAlias

map_type: TypeAlias = Mapping[int, "map_type | set_type | bool"] | Mapping[str, "map_type | set_type | bool"]
set_type: TypeAlias = set[int] | set[str]


def ensure_dict_aliased(value: map_type | set_type) -> map_type:
    """ERROR - "dict[int | str, map_type | bool]" is not assignable to "Mapping[int, map_type | bool]" - reportReturnType"""
    if isinstance(value, Mapping):
        return {k: v for k, v in value.items()}
    else:
        return {k: True for k in value}


def ensure_dict_generics[K: (int, str)](value: Mapping[K, bool] | set[K]) -> Mapping[K, bool]:
    """VALID"""
    if isinstance(value, Mapping):
        return {k: v for k, v in value.items()}
    else:
        return {k: True for k in value}
    

def ensure_dict_generics_recursion[K: (int, str)](
    value: Mapping[K, map_type | set_type | bool] | set[K],
) -> Mapping[K, map_type | bool]:
    """Error"""
    if isinstance(value, Mapping):
        return {
            k: ensure_dict_generics_recursion(v) if isinstance(v, Mapping | set) else v
            for k, v in value.items()
        }
    else:
        return {k: True for k in value} 

[DakotaB75]

Hey! I ran into the same Pyright issue with dict[int, bool] | dict[str, bool]. The trick is to use recursive TypeAlias + Generics to preserve key types:

from collections.abc import Mapping
from typing import TypeAlias, TypeVar

K = TypeVar("K", int, str)
MapType: TypeAlias = Mapping[int, "MapType | set[K] | bool"] | Mapping[str, "MapType | set[K] | bool"]

def ensure_dict_recursive(value: MapType | set[K] | bool) -> MapType:
    if isinstance(value, Mapping):
        return {k: ensure_dict_recursive(v) if isinstance(v, (Mapping, set)) else v for k, v in value.items()}
    elif isinstance(value, set):
        return {k: True for k in value}
    return value

This keeps Pyright happy with recursive dicts and mixed key types. I’m working on a PR to make this easier for everyone...

[mvanderlee]

Thank you for the reply @DakotaB75. It's close but not quite there since now the nested type is locked to the root type.
i.e.: If the root is str then all children must be str as well.

I want each child type to be either str or int again, regardless of the parent
Your example was still raising multiple type errors with 1.1.407 on Python 3.13, resulting in MapType[Unknown] I think I resolved that.

from collections.abc import Mapping
from typing import TypeAlias, TypeVar

K = TypeVar("K", int, str)

MapType: TypeAlias = Mapping[K, "MapType | set[K] | bool"]

def ensure_dict_recursive(value: MapType[K] | set[K]) -> MapType[K]:
    if isinstance(value, Mapping):
        return {k: ensure_dict_recursive(v) if isinstance(v, (Mapping, set)) else v for k, v in value.items()}
    else:
        return {k: True for k in value}
    
valid = ensure_dict_recursive({"a": True, "b": {"c"}})
valid_2 = ensure_dict_recursive({"a", "b"})
valid_3 = ensure_dict_recursive({1: True, 2: {3}})
valid_4 = ensure_dict_recursive({1, 2})

invalid = ensure_dict_recursive({"a": True, "b": {1}})
invalid_2 = ensure_dict_recursive({1: True, 2: {"a"}})

[DakotaB75]

Yep, that’s the key limitation.
Once K is bound at the root, Python’s type system can’t re-widen it per nesting level.
What you’re modeling (each node independently being int | str) isn’t representable today with recursive generics.
Your final example is essentially the least wrong option:
it enforces consistency within a tree, even if it can’t express mixed-key subtrees.
Anything more flexible would require higher-kinded types or per-level type rebinding, which Python typing doesn’t support yet.