Permit covariance of key type in read_csv converters argument

[gandhis1]

• Tests added: Please use assert_type() to assert the type of any return value

If it accepts a Dict[int | str, ...] it should accept a Dict of either key type.

[gandhis1]

Originally I wanted this dictionary to be {"A": str, "B": str}. But the type of str is Type[str], which apparently isn't compatible with Callable[[str], Any]. Any idea if this is fixable?

[Dr-Irv]

Might be an issue with using a lambda function, which is untyped. So if you did

def convert_to_str(a: object) -> str:
    return str(a)

and then

converters1 = {"A":convert_to_str, "B": convert_to_str}

that might work

[gandhis1]

Oh, the current version works fine because it's actually a Callable. What isn't working is passing Type[str] directly. That makes the dict a Dict[str, Type[str]]. That's what I was wondering about.

[Dr-Irv]

I guess the type checkers know that str could be either a type or a callable.

[Dr-Irv]

Try avoiding the lambda if you can. (or at least add tests without it)

[Dr-Irv]

Can you try Mapping[int | str, Callable[[str], Any]] instead of the union?

[gandhis1]

I tried that first. But it seems Mapping isn't covariant over the key, only the value: python/typing#445

[gandhis1]

But mapping may work for that the Type[str] issue since that is the value...will try that

I also wonder if creating a covariant TypeVar and then a Mapping[T_co, ...] will work...I will also try that.

[gandhis1]

Ok, the version I just pushed should fix all of that, and also fix the other parameters too - na_values and parse_dates.

This is something that is probably going to come up over and over again throughout this code base. I think as a rule of thumb all Dict inputs need to be a Mapping if we want value covariance, and we need to do unions if we want key covariance. And honestly I would guess the overwhelming majority of places we want both.

[Dr-Irv]

This is something that is probably going to come up over and over again throughout this code base. I think as a rule of thumb all Dict inputs need to be a Mapping if we want value covariance, and we need to do unions if we want key covariance. And honestly I would guess the overwhelming majority of places we want both.

I think we have to look at all of them and see. Probably dict[str, int] is OK, but if we have two or more possibilities for the value, then we should switch to Mapping, and if we have two or more possibilities for the key, then we have to use the pattern you used here by including each possible key with union.

[Dr-Irv]

thanks @gandhis1