Generic Static Protocols Help

[InvincibleRMC]

Since ClassVar's of Type Variable is not allowed is there anything better that can be done then BadSrv?

from typing import ClassVar, TypeVar, Protocol

class Msg(Protocol): ...

RequestT = TypeVar('RequestT', bound=Msg)
ResponseT = TypeVar('ResponseT', bound=Msg)

#Ideal
class Srv(Protocol[RequestT, ResponseT]):
    Request: ClassVar[type[RequestT]]
    Response: ClassVar[type[ResponseT]]

#Jank with TypeAlias, but not supported in protocol
class SrvTypeAlias(Protocol[RequestT, ResponseT]):
    type Request = type(RequestT)
    type Response = type(ResponseT)
 
#Current Solution
 class BadSrv(Protocol):
    Request: ClassVar[type[Msg]]
    Response: ClassVar[type[Msg]]


#Example Service for reference
class DescribeParameters:
    from rcl_interfaces.srv._describe_parameters import DescribeParameters_Request as Request
    from rcl_interfaces.srv._describe_parameters import DescribeParameters_Response as Response

[erictraut]

Here are a couple of suggestions.

Option 1: Don't use a ClassVar

Simply omit the ClassVar in the protocol definition. Type checkers will then treat these attributes as instance variables. The only downside to this approach is that users of the protocol will be able to overwrite the default value of the attribute (which is a class variable) with an instance value. That's probably something you'd want a type checker to prevent, but there's currently no official way to do this in the typing spec.

This limitation was discussed in the typing forums a while back. In response, I added support in pyright for Final attributes in a protocol definition. The typing spec doesn't officially allow or disallow Final attributes in a protocol. It's something that we could formalize if it's generally useful. Mypy currently rejects this usage.

Here's what that would look like...

Code sample in pyright playground

from typing import Final, Protocol

class Msg(Protocol): ...

class Srv[RequestT: Msg, ResponseT: Msg](Protocol):
    Request: Final[type[RequestT]]
    Response: Final[type[ResponseT]]

class RequestA(Msg): ...
class ResponseA(Msg): ...
class ServiceA:
    Request: Final = RequestA
    Response: Final = ResponseA

def get_request_response[RequestT: Msg, ResponseT: Msg](
    x: Srv[RequestT, ResponseT],
) -> tuple[RequestT, ResponseT]: ...

v = get_request_response(ServiceA)
reveal_type(v)  # tuple[RequestA, ResponseA]

Option 2: Describe the class not the object

Protocols are typically used to describe the shape of an object (a class instance), but they can be used to describe the shape of a class object (i.e. an instance of type). That may work for you in this case depending on whether there are other attributes and methods of Srv that you want to include in the protocol definition. This approach avoids the need to describe Request and Response as class variables. From the perspective of the class object, they are simply instance variables.

Here's the relevant part of the typing spec. In particular, it says:

A class object is considered an implementation of a protocol if accessing all members on it results in types assignable to the types of the protocol members.

Here's how you can apply this to your use case...

Code sample in pyright playground

from typing import ClassVar, Protocol

class Msg(Protocol): ...

class SrvClass[RequestT: Msg, ResponseT: Msg](Protocol):
    Request: type[RequestT]
    Response: type[ResponseT]

class RequestA(Msg): ...
class ResponseA(Msg): ...
class ServiceA:
    Request: ClassVar = RequestA
    Response: ClassVar = ResponseA

def get_request_response_classes[RequestT: Msg, ResponseT: Msg](
    cls: SrvClass[RequestT, ResponseT],
) -> tuple[type[RequestT], type[ResponseT]]:
    return cls.Request, cls.Response

v = get_request_response_classes(ServiceA)
reveal_type(v)  # tuple[type[RequestA], type[ResponseA]]