How to get TypeScript's keyof behavior to type API response from route string

[johhnry]

Hi,

When typing REST API responses, I usually use this pattern in TypeScript:

type Routes = {
  "/users": User[];
  "/jobs": Job[];
};

type Route = keyof Routes; // "/users" | "/jobs"

function getFromAPI<R extends Route>(route: R): Routes[R] {
  return // ...
}

const users = getFromAPI("/users"); // User[]
const jobs = getFromAPI("/jobs"); // Job[]

This is really handy because now I just need to specify the API endpoint and it uses the corresponding return type for me.

I want to reproduce this in Python with the httpx library, so I have:

def get_from_api(route: str):
    response: httpx.Response = httpx.get(route)
    return response.json()

The issue here is that the return type is Any which is not ideal.

I didn't find how to reproduce this example from TypeScript with generic function return type (which is not in any arguments):

function getFromAPI<ResponseType>(route: string): ResponseType {
  return // ...
}

const users = getFromAPI<User[]>("/users"); // User[]

https://stackoverflow.com/questions/72793247/specify-generic-return-type-without-relying-on-arguments-in-python

So I found this hack with a callable generic class:

ResponseType = TypeVar("ResponseType")

class get_from_api(Generic[ResponseType]):
    def __call__(self, route: str) -> ResponseType:
        response: httpx.Response = httpx.get(route)
        return response.json()

users = get_from_api[list[User]]()("/users")  # list[User]

I think this isn't the best way by far to achieve this and even more if I want the response type to depend on the route value (keyof behavior).

Linked an issue about Keyof type: #685
Is is still relevant for Python 3.11?

Any feedback and input would be greatly appreciated, thanks! ;)

[jeremyn]

I haven't tried this but your link #685 has another link to python/mypy#7856 which has an example that might help. Here's an excerpt:

    @overload
    def __getitem__(self, key: Literal["a"]) -> str:
        ...

    @overload
    def __getitem__(self, key: Literal["b", "c"]) -> int:
        ...

This is like what you're asking for, mapping arbitrary constants like /users to types like list[User], though it doesn't pull values automatically from another type like keyof does.

Does this help?