Retrofitting Dependency Injection System With Pyright: Force Non-Data Protocol Check

[ianjosephwilson]

I have a protocol setup sort of working as below for dependency injection. The scanning and registration is done via venusian which sort of side steps the regular flows which is good... and bad. There is no "concrete" connection between the implementation, BundleService, and the "interface" (protocol), BundleProtocol. Is there a way to tell pyright to just check the implementation matches the protocol without doing some sort of manual check after every declaration?

A manual check, check_service(), is done in the example below. I could move this "manual" check into the decorator but it is still using a weaker signature check provided by python instead of pyright's more robust signature checking (AFAIK). I don't know what to search for, if this is super obvious and already exists, maybe something like class BundleService: # pyright: force_check(BundleProtocol) ?

So in more plain-speak I'm looking for something that does this:
pyright please always statically check that this class is implementing the non-data (methods only) protocol provided in this protocol

Here is a rough example of what I have now:

Define Service

# ./services/bundle.py
from ..protocols import BundleProtocol, JsonProtocol

@register_service(BundleProtocol)
class BundleService:
    json_api: JsonProtocol

    def get_bundle_config_json(self) -> dict[str, dict[str, str]]:
        return self.json_api.to_json({})

def check_service(api, proto):
    if not issubclass(api, proto):
        raise AssertionError(f"The service {api} should implement {proto}.")

check_service(BundleHelperService, BundleHelperProtocol)

Define Protocols

# ./protocols.py
from typing import Protocol, runtime_checkable, Any
@runtime_checkable
class BundleProtocol:
    def get_bundle_config_json(self) -> dict[str, dict[str, str]]:
        ...
@runtime_checkable
class JsonProtocol:
    def to_json(self, obj: dict[str, Any]) -> str:
        ...

Use service

#./handlers.py

@handle_get()
def handle_request(request: RequestProtocol) -> dict[str, str]:
    # statically this will essentially be an implicit or explicit "cast"
    bundle_api = request.find_service(BundleProtocol)
    return {"bundle_config_json": bundle_api.get_bundle_config_json()}

[Glinte]

Why can't you just subclass the protocol class BundleService(BundleProtocol):

[ianjosephwilson]

That is embarrassing. Sometimes it really is that easy. Thanks; It works great!

I don't know if I had some issue before or I just completely spaced when reading the docs.

https://typing.python.org/en/latest/spec/protocol.html#explicitly-declaring-implementation

Note that there is little difference between explicitly subclassing and implicitly implementing the protocol; the main benefit of explicit subclassing is to get some protocol methods “for free”. In addition, type checkers can statically verify that the class actually implements the protocol correctly: