Record Types #685

saulshanabrook · 2019-11-11T14:49:27Z

I would like to be able to type a Dataframe like object with MyPy, where different columns have different types and you can get each as column as an attribute on the dataframe. This is how libraries like Pandas and Ibis work.

Generally, this requires a function to return different types by mapping string literals to different types (record kinds).

Here is a mock example implemented in Typescript, which checks properly:

class Column {
    mean(): number {
        return 0;
    }
}

class GeoColumn extends Column {
    length(): number {
        return 0;
    }
}

class Dataframe<T extends { [key: string]: Column} > {

    constructor(private cols: T) {

    }

    getColumn<K extends keyof T>(name: K): T[K] {
        return this.cols[name]
    }
}

const d = new Dataframe({ name: new Column(), location: new GeoColumn() });

d.getColumn("name").mean();
// We can call `length` because this is a GeoColumn
d.getColumn("location").length();

Possible Syntaxes

Here are a few possible ways this could be spelled in Python:

`self` as `TypedDict`

Since we already have a TypedDict construct one of the least invasive approaches is to type self as a TypeDict.

This would probably require anonymous TypeDicts, which was proposed previously (python/mypy#985 (comment)).

It would also required TypedDicts to be able to take generic parameters.

class Column:
    def mean(self) -> int:
        return 0


class GeoColumn(Column):
    def length(self) -> int:
        return 0


T = TypeVar("T", bound=Dict[str, Column])

K = TypeVar("K", bound=str)
V = TypeVar("V", bound=Column)


class Dataframe(Generic[T]):
    def __init__(self, cols: T):
        self.cols = cols

    def __getattr__(self: Dataframe[TypedDict({K: V})], name: K) -> V:
        return self.cols[name]


d = Dataframe({"name": Column(), "location": GeoColumn()})

d.name.mean()
d.location.length()

Type Level `.keys` and `getitem`

Another option would be to mirror how Typescript does this, by introducing type level keys and __gettitem__ functions. This would also require generic to depend on other generics (python/mypy#2756).

T = TypeVar("T", bound=Dict[str, Column])

K = TypeVar("K", bound=KeyOf[T])


class Dataframe(Generic[T]):
    def __init__(self, cols: T):
        self.cols = cols

    def __getattr__(self, name: K) -> GetItem[T, K]:
        return self.cols[name]

Conclusion

I would like to have a way to type Dataframes that have different column types in a generic way. This is useful for typing frameworks like Ibis or Pandas.

This is somewhat related to variadic generics I believe (#193). Also related: dropbox/sqlalchemy-stubs#69

ilevkivskyi · 2019-11-11T16:11:03Z

This was discussed during one of last typing meet-ups, see at the bottom of summary. I proposed to call these key types (essentially they will act as string generic, similar to integer generics). The syntax I tend to like the most is something like this for attributes (proposed by Guido IIRC):

K = Key("K")

class Proxy(Generic[T]):
    def __init__(self, target: T):
        self.target = target
    def __getattr__(self, name: K) -> T.K:
        return self.target.name

and T[K] for TypedDicts (initially I thought about the latter for both). The syntax for TypedDicts would be still too similar to generics (and will block addition of support for generic TypedDict types), so maybe after all we will settle on something verbose like AttrOf[T, K] and ItemOf[T, K].

Anyway, IMO the question of syntax is not important an this point. This topic (support for static typing of Python numeric stack) is obviously important (but gets constantly deprioritized for mypy team). Also I would say we should start with integer generic (shape types), and string generic (key types) will follow next.

See also an essentially the same proposal on mypy tracker python/mypy#7856

saulshanabrook · 2019-11-11T22:44:33Z

The syntax for TypedDicts would be still too similar to generics (and will block addition of support for generic TypedDict types)

Yeah that's why I avoided it.

Do you have a sense if something like this could be first written as a MyPy extension before integrated into core, so we could start building/playing with it?

ilevkivskyi · 2019-11-11T22:46:14Z

Do you have a sense if something like this could be first written as a MyPy extension before integrated into core, so we could start building/playing with it?

Unfortunately, I don't think it is possible, it requires changes in some very deep parts of mypy.

saulshanabrook · 2019-11-11T22:48:46Z

it requires changes in some very deep parts of mypy

Sounds exciting! :) Well if I end up having bandwidth to work on this I will start poking around and asking more questions.

Sep	OCT	Nov
	19
2019	2020	2021

python / typing

Record Types #685

Record Types #685

saulshanabrook commented Nov 11, 2019 •

edited

ilevkivskyi commented Nov 11, 2019

saulshanabrook commented Nov 11, 2019

ilevkivskyi commented Nov 11, 2019

saulshanabrook commented Nov 11, 2019

python / typing

Join GitHub today

Record Types #685

Record Types #685

Comments

saulshanabrook commented Nov 11, 2019 • edited

Possible Syntaxes

self as TypedDict

Type Level .keys and __getitem__

Conclusion

ilevkivskyi commented Nov 11, 2019

saulshanabrook commented Nov 11, 2019

ilevkivskyi commented Nov 11, 2019

saulshanabrook commented Nov 11, 2019

Essential cookies

Always active

Analytics cookies

saulshanabrook commented Nov 11, 2019 •

edited

`self` as `TypedDict`

Type Level `.keys` and `getitem`