Defining a generic parameter with a default value in Python

Question

Let's say I have the following code:

from typing import Literal, TypeVar, Generic

T = TypeVar("T", bound=str)

class Foo(Generic[T]):
    def foo(self, arg: T = "foo") -> T:
        return arg

The idea is that I have a generic class with a concrete method that takes a string, but the child classes can define a more restrictive input than any string, for example this class will only accept "bar":

class Bar(Foo[Literal["bar"]]):
    pass

However, the original code doesn't pass any type checker. Both mypy and pyright complain. The mypy error is:

test.py:6: error: Incompatible default for argument "arg" (default has type "str", argument has type "T")

I would have thought this would be okay, because T has an upper bound which is a string. However I think the issue is that the default argument "foo" no longer makes sense if the child class accepts only "bar". How then can I define T such that it must always allow the literal "foo", but the child class can also define additional strings it will accept?

You could I guess make new type that is a union between T and your litteral ? — Sami Tahri
– Sami Tahri, Commented Aug 23, 2022 at 10:01
Oh, good point, I can do ArgType = Union[T, Literal["foo"]] and then def foo(self, arg: ArgType = "foo") -> ArgType. — Migwell
– Migwell, Commented Aug 23, 2022 at 10:21

Paweł Rubin · Accepted Answer · 2022-08-23 12:27:15Z

3

In addition to a suggestion from comments, consider using typing.overload:

from typing import TYPE_CHECKING, Literal, TypeVar, Generic, overload
from typing_extensions import reveal_type

T = TypeVar("T", bound=str | Literal["foo"])


class Foo(Generic[T]):
    @overload
    def foo(self, arg: T) -> T:
        ...

    @overload
    def foo(self) -> Literal["foo"]:
        ...

    def foo(self, arg: T | Literal["foo"] = "foo") -> T | Literal["foo"]:
        return arg


class Bar(Foo[Literal["bar"]]):
    pass


if TYPE_CHECKING:
    reveal_type(Bar().foo("bar"))  # Revealed type is "Literal['bar']"
    reveal_type(Bar().foo())  # Revealed type is "Literal['foo']"

answered Aug 23, 2022 at 12:27

Paweł Rubin

3,6992 gold badges24 silver badges32 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Rob Percival · Accepted Answer · 2024-03-13 09:43:02Z

0

The idea is that I have a generic class with a concrete method that takes a string, but the child classes can define a more restrictive input than any string

This is a violation of the Liskov Substitution Principle (LSP), so mypy and pyright are correct to refuse it. A child class needs to accept anything that the parent class accepts, otherwise you can't freely substitute a child class for the parent class. You can do the opposite though; a child class is allowed to be more permissive than the parent.

answered Mar 13, 2024 at 9:43

Rob Percival

585 bronze badges

Collectives™ on Stack Overflow

Defining a generic parameter with a default value in Python

2 Answers 2

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related