typing related issues to custom record class.

[iyad-f]

so i just type hinted a user record like

class User(asyncpg.Record):
    if TYPE_CHECKING:
        id: int
        username: str
        password: str

    def __getattr__(self, name: str) -> Any:
        return self[name]

but i get the following error from pyright

so do i need to do some additional stuff for this?

[ltianyi992]

The issue is that asyncpg.Record uses __slots__ and its attributes are accessed via __getitem__, not __getattr__. Pyright sees Record has no fields named id, username, etc., so it reports the type error even with the TYPE_CHECKING guard.

The cleaner approach is to use a TypedDict or Protocol for type hints instead of subclassing asyncpg.Record:

Option 1 — TypedDict (recommended for query results)

from typing import TypedDict
import asyncpg

class UserRecord(TypedDict):
    id: int
    username: str
    password: str

# Cast the result
row = await conn.fetchrow("SELECT id, username, password FROM users WHERE id = $1", user_id)
user: UserRecord = dict(row)  # type: ignore[assignment]
print(user["username"])  # fully typed

Option 2 — Keep subclassing but suppress the Pyright error

Pyright does not support __getattr__ as a dynamic attribute resolver for Record subclasses. You need to declare the attributes as class variables directly (not inside TYPE_CHECKING):

from typing import Any
import asyncpg

class User(asyncpg.Record):
    id: int          # declare directly
    username: str
    password: str

    def __getattr__(self, name: str) -> Any:
        return self[name]

Declaring them outside TYPE_CHECKING makes Pyright aware of the attributes at analysis time. The attributes will not actually exist as instance vars at runtime (access goes through __getattr__ → __getitem__), but type checking will work.

Option 3 — Use record_class parameter

Asyncpg supports passing a custom record_class to query methods, but that class must be a Record subclass. Combine with a Protocol for typing:

from typing import Protocol

class UserLike(Protocol):
    @property
    def id(self) -> int: ...
    @property
    def username(self) -> str: ...

For most cases, Option 1 (TypedDict) is the least friction and works well with type checkers.

[iyad-f]

Hi, firstly i would say you shouldn't be answering questions with ai generated content, there are clear em dashes in your response and other than that the whole thing is generated by ai, for anyone who has seen ai generated responses its a no brainer to tell its ai generated.

Now coming to the solutions provided here, the first one clearly ain't a solution because the goal here is to make a custom record class. As for the second one the if TYPE_CHECKING block has nothing to do with this, pyright simply cant find that id, username or password are being initialised in the record class in the constructor. As for the third solution the custom record class being typed was because i wanted to pass that record class as a param only.

Anyways the solution i found to this was using typing.dataclass_transform decorator to make type checkers think this class behaves like a dataclass and the attributes typed will be somehow initialised, similar to what msgspec.Struct does for typing it

[bryanforbes]

I'm the author of asyncpg-stubs. Your best bet will be to do one of the following:

Option 1: use dict-like access and trick the type checker to think your class is both TypedDict and asyncpg.Record

# types.py:
from typing import TYPE_CHECKING, TypedDict

import asyncpg

if TYPE_CHECKING:

    class Record(asyncpg.Record, TypedDict): ...  # pyright: ignore
else:
    Record = asyncpg.Record

# another_module.py:
from .types import Record

class MyRecord(Record):
    id: int
    username: str
    password: str

async def do_something() -> None:
    row = await conn.fetchrow("SELECT id, username, password FROM users WHERE id = $1", user_id, record_class=MyRecord)
    assert_type(row['id'], int)

Option 2: use dotted notation and trick the type checker with dataclass_transform and always use dotted notation:

# types.py:
from typing import TYPE_CHECKING, Any

import asyncpg

if TYPE_CHECKING:

    @dataclass_transform(eq_default=True, order_default=True)
    class Record(asyncpg.Record): ...
else:

    class Record(asyncpg.Record):
        def __getattr__(self, name: str) -> Any:
            return self[name]

# another_module.py:
from .types import Record

class MyRecord(Record):
    id: int
    username: str
    password: str

async def do_something() -> None:
    row = await conn.fetchrow("SELECT id, username, password FROM users WHERE id = $1", user_id, record_class=MyRecord)
    assert_type(row.id, int)

It sounds like you did something similar to option 2, but I would recommend using the if TYPE_CHECKING/else block so that the type checker doesn't see __getattr__() and allow any property with a type of Any.

[iyad-f]

Yeah as i mentioned above in the earlier comment i figured i would use dataclass_transform. Thankyou for your response though

[bryanforbes]

You're welcome! I didn't want the solution to get lost 😄 and wanted to make sure you knew to use the TYPE_CHECKING block.

[iyad-f]

Yeah ofcourse, i marked this one as answer, also yeah in my earlier comment i didn't mention the type checking block, but i definately use it, although i did forget to use eq_default=True, order_default=True, will keep those in mind, thnx again.