`choices` is being treated as a tuple rather than a string in the latest version of Pyright

[tylerlaprade]

After upgrading to Pyright 1.1.402, I have a bunch of type errors regarding unnecessaryComparison. I'm not sure exactly where the breakdown is happening, but it feels specific to this library as there are no other false positives.

[last-partizan]

I think we cannot fix this on type level, that's pyright problem.

microsoft/pyright#10606

[tylerlaprade]

@last-partizan The only way to detect this would be for Pyright to evaluate the equals method on every object, which I don't think is in-scope for a type-checker

[last-partizan]

The point is: it was working before. So it's technically possible on type-checker level. But something got reverted and now it no longer works.

• StrEnum and IntEnum values should not be subtypes of Literal[<str>] or Literal[<int>] microsoft/pyright#10552

I'd be happy to fix this on django-types level, but I don't know if it is possible.

[nuschk]

FWIW, I find that using TextChoices with typed code is not optimal anyway. The choices class is actually an enum, but most of the time it behaves like a literal string. This can lead to subtle bugs and confusions.

I've resorted to using literals directly:

   Product = Literal[
        "vanilla",
        "chocolate",
    ]
    product: Products = models.CharField(
        max_length=256,
        null=False,
        blank=False,
        choices=make_choices(Product),
    )  # type: ignore[reportAssignmentType]

Where

def make_choices(literal: Any) -> Iterable[tuple[Any, str]]:
    values = _get_flattened_literal_values(literal)
    c: Any = models.TextChoices("Choices", [(v, v) for v in values])
    return c.choices

def _get_flattened_literal_values(literal: Any) -> Iterable[str]:
    values = get_args(literal)
    for value in values:
        if get_origin(value) is Literal:
            yield from _get_flattened_literal_values(value)
        else:
            yield value

If the type: ignore annoys anyone, I also have a typed charfield in my utils, which removes the necessity for that:

_ValidatorCallable = Callable[..., None]
_ErrorMessagesToOverride = dict[str, Any]


class TypedCharField[_C: str | None](models.CharField[_C]):
    if TYPE_CHECKING:

        @overload
        def __new__(
            cls,
            verbose_name: str | None = ...,
            *,
            name: str | None = ...,
            primary_key: bool = ...,
            max_length: int = ...,
            db_collation: str | None = ...,
            unique: bool = ...,
            blank: bool = ...,
            null: Literal[False] = False,
            db_index: bool = ...,
            default: _C | Callable[[], _C] | None = ...,
            db_default: _C | Func | None = ...,
            editable: bool = ...,
            auto_created: bool = ...,
            serialize: bool = ...,
            unique_for_date: str | None = ...,
            unique_for_month: str | None = ...,
            unique_for_year: str | None = ...,
            choices: (
                Iterable[tuple[_C, str] | tuple[str, Iterable[tuple[_C, str]]]] | type[TextChoices]
            ) = ...,
            help_text: str = ...,
            db_column: str | None = ...,
            db_comment: str | None = ...,
            db_tablespace: str | None = ...,
            validators: Iterable[_ValidatorCallable] = ...,
            error_messages: _ErrorMessagesToOverride | None = ...,
        ) -> models.CharField[_C]: ...

        @overload
        def __new__(
            cls,
            verbose_name: str | None = ...,
            *,
            name: str | None = ...,
            primary_key: bool = ...,
            max_length: int = ...,
            db_collation: str | None = ...,
            unique: bool = ...,
            blank: bool = ...,
            null: Literal[True],
            db_index: bool = ...,
            default: _C | Callable[[], _C] = ...,
            db_default: _C | Func = ...,
            editable: bool = ...,
            auto_created: bool = ...,
            serialize: bool = ...,
            unique_for_date: str | None = ...,
            unique_for_month: str | None = ...,
            unique_for_year: str | None = ...,
            choices: (
                Iterable[tuple[_C, str] | tuple[str, Iterable[tuple[_C, str]]]] | type[TextChoices]
            ) = ...,
            help_text: str = ...,
            db_column: str | None = ...,
            db_comment: str | None = ...,
            db_tablespace: str | None = ...,
            validators: Iterable[_ValidatorCallable] = ...,
            error_messages: _ErrorMessagesToOverride | None = ...,
        ) -> models.CharField[_C | None]: ...

        def __new__(cls, *args: Any, **kw: Any) -> models.CharField[Any]:
            # We can't properly type this, because there's a bug in django-types, where
            # max_length is not nullable. So, we'd have to type: ignore some stuff. Might as
            # well do it wholesale.
            return super().__new__(cls, *args, **kw)  # type: ignore

Elegant? No. But the resulting client code will be much simpler.

Edit: Of course, when you actually DO want to use choices for their translations, then that doesn't work. I'm building mostly APIs, so I don't care about this.