How to type dynamically created class methods

I have a class which is used to send requests to server.

There's a ROUTES dictionary which is a map of class method names to the server endpoint used in request function.

These methods are added to class in __init__ with setattr. I could've just added these methods to the class, but there are a lot of them and I hate code duplication.

Class looks like this:

ROUTES = {
    "send_test": ["GET", "/test/"],
    "send_start": ["GET", "/start/"]
}

class Response(TypedDict):
    ...

class Client(object):
    def __init__(self) -> None:
        for mname, endpoint in ROUTES.items():
            setattr(self, mname, self.make_request_func(endpoint[0], endpoint[1]))

    def make_request_func(self, method, path): 
        def _func(*args, **kwargs):
            return self.request(method, path, *args, **kwargs)
        return _func

    def request(self, method, path, data: dict = {}, files: Optional[dict] = None) -> Response:
        ...

I basically need these send_test and send_start methods to just point to an alias of request function, but without method and path arguments, only data and files.

I have a very basic knowledge of python's typing, I will appreciate any additional explanation of typing this!

If you are willing to be a little less DRY and define instance methods explicitly, the following should work. (Let's face it, the repeated calls to makerequest aren't really any more repetitive than the original definition of ROUTES.)

from typing import Optional, Callable

def makerequest(method: str, path: str) -> Callable[[Client, Optional[dict], Optional[dict]], Response]:
    def wrapper(self: Client, data: Optional[dict] = None, files: Optional[dict] = None) -> Response:
        return self.request(method, path, data, files)
    return wrapper

class Client(object):
    def __init__(self) -> None:
        ...

    send_test = makerequest("GET", "/test/")
    send_start = makerequest("GET", "/start/")

    def request(self, method, path, data: Optional[dict] = None, files: Optional[dict] = None) -> Response:
        ...

(I took the liberty of replacing your default dict value with None, to avoid problems with mutable default values.)

With this, mypy reports the revealed type of Client.send_test as

tmp.py:32: note: Revealed type is "def (tmp.Client, Union[builtins.dict[Any, Any], None], Union[builtins.dict[Any, Any], None]) -> TypedDict('tmp.Response', {})"

Adapting this to allow defining the aliases by iterating over ROUTES will be at best, I think, a mess, and at worst not possible, due to the class attributes send_test etc not being statically defined.

If typing weren't an issue, I would recommend a class decorator to define the methods.

ROUTES = {...}

def add_aliases(d: dict):
    def _(cls):
        for name, args in d.items():
            setattr(cls, name, makereqeust(*args))
        return cls
    return _


def makerequest(method, path):
    ...


@add_aliases(ROUTES)
class Client:
    def request(self, ...):
        ...

The problem is annotating add_aliases and _ in a way that captures the idea of the class that _ returns having methods of the desired type, since nothing can be inferred from the body of add_aliases alone.