python-typemap/typemap/typing.py at 4cbf96d052d2b96a0be40d13387b7c2c077ead58 · vercel/python-typemap · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
import typing

from .type_eval._special_form import (
    _IterGenericAlias,
    _IsGenericAlias,
    _SpecialForm,
    _register_bool_special_form,
)

# Not type-level computation but related


class BaseTypedDict(typing.TypedDict):
    pass


class SpecialFormEllipsis:
    pass


###


# We really need to be able to represent generic function types but it
# is a problem for all kinds of reasons...
# Can we bang it into Callable??
class GenericCallable[
    TVs: tuple[typing.TypeVar, ...],
    C: typing.Callable | staticmethod | classmethod,
]:
    pass


###

MemberQuals = typing.Literal["ClassVar", "Final"]


class Member[N: str, T, Q: MemberQuals = typing.Never, D = typing.Never]:
    pass


type GetName[T: Member] = GetArg[T, Member, 0]  # type: ignore[valid-type]
type GetType[T: Member] = GetArg[T, Member, 1]  # type: ignore[valid-type]
type GetQuals[T: Member] = GetArg[T, Member, 2]  # type: ignore[valid-type]
type GetDefiner[T: Member] = GetArg[T, Member, 3]  # type: ignore[valid-type]


ParamQuals = typing.Literal["*", "**", "="]


class Param[N: str | None, T, Q: ParamQuals = typing.Never]:
    pass


type GetParamName[T: Param] = GetArg[T, Param, 0]  # type: ignore[valid-type]
type GetParamType[T: Param] = GetArg[T, Param, 1]  # type: ignore[valid-type]
type GetParamQuals[T: Param] = GetArg[T, Param, 2]  # type: ignore[valid-type]


class Attrs[T]:
    pass


class Members[T]:
    pass


class FromUnion[T]:
    pass


class GetAttr[Lhs, Prop]:
    pass


class GetArg[Tp, Base, Idx: int]:
    pass


class GetArgs[Tp, Base]:
    pass


class Length[S: tuple]:
    pass


class Uppercase[S: str]:
    pass


class Lowercase[S: str]:
    pass


class Capitalize[S: str]:
    pass


class Uncapitalize[S: str]:
    pass


class StrConcat[S: str, T: str]:
    pass


class StrSlice[S: str, Start: int | None, End: int | None]:
    pass


class NewProtocol[*T]:
    pass


##################################################################


@_SpecialForm
def Iter(self, tp):
    return _IterGenericAlias(self, (tp,))


@_SpecialForm
def IsSubtype(self, tps):
    return _IsGenericAlias(self, tps)


@_SpecialForm
def IsSubSimilar(self, tps):
    return _IsGenericAlias(self, tps)


Is = IsSubSimilar


def bool_special_form(cls):
    return _register_bool_special_form(cls)