_TableT is not compatible with TypedDict

[Glinte]

Bug report

• I confirm this is a bug with Supabase, not with my own application.
• I confirm I have searched the Docs, GitHub Discussions, and Discord.

Describe the bug

postgrest-py/postgrest/_async/client.py

Lines 15 to 21 in 576a5b8

	from ..version import __version__
	from .request_builder import AsyncRequestBuilder, AsyncRPCFilterRequestBuilder
	_TableT = Dict[str, Any]
	class AsyncPostgrestClient(BasePostgrestClient):

_TableT should be MutableMapping[str, Any] (Edit: Mapping[str, Any]) instead of dict[str, Any] to allow for users to specify a TypedDict as the output type. This seems to be a new-ish regression because my type checker wasn't complaining 4 months ago (edit: this is because there was no _TableT in postgrest 0.19.3 )

Issues from the two main type checkers explaining why dict is not compatible with TypedDict by design
mypy: python/mypy#4976
pyright: microsoft/pyright#6658

To Reproduce

async def f():
    db = AsyncClient(supabase_url, supabase_key, options)
    response: APIResponse[MessageRecord] = await db.table("messages").select("*").execute()

class MessageRecord(TypedDict):
    content: str | None

Expected behavior

Using a TypedDict should be accepted

System information

• OS: Windows
• postgrest-py: 1.0.1

[silentworks]

I've had a look at this and even with the change your propose it's still not accepting the new type defined on the returned response. What I've found to work is to not worry about the type at the .execute() level but rather do the type conversion with a Pydantic model by dumping the response to a model.

import os
import asyncio
from typing import Annotated

from dotenv import load_dotenv
from postgrest.exceptions import APIError
from postgrest._async.client import AsyncPostgrestClient
from pydantic import BaseModel, Field

load_dotenv()

url = os.environ.get("SUPABASE_URL", "")
key = os.environ.get("SUPABASE_KEY", "")

class Country(BaseModel):
    id: Annotated[int, Field(alias="id")]
    name: Annotated[str, Field(alias="name")]

def Countries(data: list):
    return [Country(**x) for x in data]

class CountryResponse(BaseModel):
    count: Annotated[int | None, Field(alias="count")]
    data: Annotated[list[Country], Field(alias="data")]

async def main():
    headers = {"Authorization": f"Bearer {key}"}
    async with AsyncPostgrestClient(base_url=f"{url}/rest/v1", headers=headers) as client:
        try:
            resp = (await client.table("countries").select("*").execute()).model_dump()
            response = CountryResponse(**resp)

            for row in response.data:
                print(f"RESPONSE: {row.id} {row.name}")
        except APIError as e:
            print(f"ERROR: {e}")

asyncio.run(main())

This might not be ideal for you but this is the current working solution I could come up with. I will investigate more to see how we can coerce the type a bit more to follow your original setup.

[Glinte]

Seems to be impossible to do inline type hint unless PEP 718 Subscriptable functions is accepted. I checked by reverted to the old version of postgrest that I was using, the reason why it worked before is because there was no _TableT so pyright just assumed Unknown i.e. Any in another name, and allows me to subscript with whatever type I want.

Reason why I believe coercing the type to my original setup is impossible is because

_TableT = Dict[str, Any]
AsyncPostgrestClient.from_(self, table: str) -> AsyncRequestBuilder[_TableT]: ...

has defined already defined the output type through the chain of classes, which passes _TableT into APIResponse[_TableT]

class APIResponse(BaseModel, Generic[_ReturnT]):
    data: List[_ReturnT]
    """The data returned by the query."""

and _ReturnT is invariant because data is list[_ReturnT] and the type parameter inside lists is invariant. What is being done right now means APIReponse.data must always be assumed to be Dict[str, Any]. Nothing that is done afterwards short of a cast can matter

Here are 3 ways that I came up that was close to what

1. Split into two lines. This works out of the box.

table: AsyncRequestBuilder[MessageRecord] = db.table("messages")
response = await table.select("*").execute()

2. Wrapping over AsyncClient/Client to add custom overloads to tables for each known table_name. This still requires _TableT = Mapping[str, Any]

class DatabaseManager(AsyncClient):
    """Wrapper class for the supabase client."""
    @overload
    def table(self, table_name: Literal["messages"]) -> AsyncRequestBuilder[MessageRecord]: ...

    @overload
    def table(self, table_name: str) -> AsyncRequestBuilder[Mapping[str, Any]]: ...

    @override
    def table(self, table_name: str) -> AsyncRequestBuilder[Mapping[str, Any]]:
        """Override the table method to add the correct type hints via overloads."""
        return self.postgrest.from_(table_name)

3. Hope PEP 718 Subscriptable functions comes out and be able to do, changing _TableT to a TypeVar with default

response = await db.table[MessageRecord]("messages").select("*").execute()