Can I allow implementors of a protocol to use any method parameter type as long as it conforms to a given protocol?

[cwoelf]

Is there a way to make the protocol Model in below code generic such that it accepts an implementation with a run method that specifies its data argument as a particular type that implements Data instead of having to allow all types that implement Data as argument type?

from abc import abstractmethod
from typing import TYPE_CHECKING, Protocol

class Data(Protocol):
    @property
    @abstractmethod
    def version(self) -> str: ...

# TODO: Make this generic such that mypy accepts GoodModel* and rejects BadModel*
class Model(Protocol):
    def run(self, data: Data) -> Data: ...

### user code starts here ###

class MyData:
    @property
    def version(self) -> str:
        return "0.0.1"

class GoodModel1:
    def run(self, data: Data) -> Data: ...

class GoodModel2:
    def run(self, data: MyData) -> MyData: ...

class GoodModel3:
    def run(self, data: Data) -> MyData: ...

class GoodModel4:
    def run(self, data: MyData) -> Data: ...

class BadModel1:
    def run(self, data: float) -> Data: ...

class BadModel2:
    def run(self, data: Data) -> float: ...

class BadModel3:
    def run(self, data: float) -> MyData: ...

class BadModel4:
    def run(self, data: MyData) -> float: ...

class BadModel5:
    def run(self, data: float) -> float: ...

if TYPE_CHECKING:
    data: Data = MyData()
    good_model_1: Model = GoodModel1()
    good_model_2: Model = GoodModel2()
    good_model_3: Model = GoodModel3()
    good_model_4: Model = GoodModel4()
    bad_model_1: Model = BadModel1()
    bad_model_2: Model = BadModel2()
    bad_model_3: Model = BadModel3()
    bad_model_4: Model = BadModel4()
    bad_model_5: Model = BadModel5()

[agammann]

Yes: make the input type a bounded, contravariant type parameter, and specialize the protocol at the point of use:

from typing import Protocol, TypeVar

T_contra = TypeVar("T_contra", bound=Data, contravariant=True)

class Model(Protocol[T_contra]):
    def run(self, data: T_contra) -> Data: ...

good_model_1: Model[MyData] = GoodModel1()
good_model_2: Model[MyData] = GoodModel2()
good_model_3: Model[MyData] = GoodModel3()
good_model_4: Model[MyData] = GoodModel4()

Using your Data and MyData definitions, this accepts all four GoodModel signatures and rejects all five BadModel signatures. I checked that with mypy 2.4.0 and Pyright 1.1.414; Model[float] was also rejected because of the bound.

The specialization matters: Model[MyData] promises that run() accepts a MyData. Model[Data] would promise that it accepts every implementation of Data, which your narrower GoodModel2 and GoodModel4 methods do not promise. Keeping the input parameter in the protocol lets callers retain that relationship instead of erasing it with an unspecialized Model.

The return type can remain Data: returning MyData satisfies that contract. See callable parameter and return variance.