Format: application/octet-stream
1 import typing
2 from typing import Optional
3
4 __version__: str
5 PyCF_ONLY_AST: int
6 _identifier = str
7
8 class AST:
9 _attributes: typing.Tuple[str, ...]
10 _fields: typing.Tuple[str, ...]
11 def __init__(self, *args, **kwargs) -> None: ...
12
13 class mod(AST): ...
14
15 class Module(mod):
16 body: typing.List[stmt]
17
18 class Interactive(mod):
19 body: typing.List[stmt]
20
21 class Expression(mod):
22 body: expr
23
24 class Suite(mod):
25 body: typing.List[stmt]
26
27 class stmt(AST):
28 lineno: int
29 col_offset: int
30
31 class FunctionDef(stmt):
32 name: _identifier
33 args: arguments
34 body: typing.List[stmt]
35 decorator_list: typing.List[expr]
36
37 class ClassDef(stmt):
38 name: _identifier
39 bases: typing.List[expr]
40 body: typing.List[stmt]
41 decorator_list: typing.List[expr]
42
43 class Return(stmt):
44 value: Optional[expr]
45
46 class Delete(stmt):
47 targets: typing.List[expr]
48
49 class Assign(stmt):
50 targets: typing.List[expr]
51 value: expr
52
53 class AugAssign(stmt):
54 target: expr
55 op: operator
56 value: expr
57
58 class Print(stmt):
59 dest: Optional[expr]
60 values: typing.List[expr]
61 nl: bool
62
63 class For(stmt):
64 target: expr
65 iter: expr
66 body: typing.List[stmt]
67 orelse: typing.List[stmt]
68
69 class While(stmt):
70 test: expr
71 body: typing.List[stmt]
72 orelse: typing.List[stmt]
73
74 class If(stmt):
75 test: expr
76 body: typing.List[stmt]
77 orelse: typing.List[stmt]
78
79 class With(stmt):
80 context_expr: expr
81 optional_vars: Optional[expr]
82 body: typing.List[stmt]
83
84 class Raise(stmt):
85 type: Optional[expr]
86 inst: Optional[expr]
87 tback: Optional[expr]
88
89 class TryExcept(stmt):
90 body: typing.List[stmt]
91 handlers: typing.List[ExceptHandler]
92 orelse: typing.List[stmt]
93
94 class TryFinally(stmt):
95 body: typing.List[stmt]
96 finalbody: typing.List[stmt]
97
98 class Assert(stmt):
99 test: expr
100 msg: Optional[expr]
101
102 class Import(stmt):
103 names: typing.List[alias]
104
105 class ImportFrom(stmt):
106 module: Optional[_identifier]
107 names: typing.List[alias]
108 level: Optional[int]
109
110 class Exec(stmt):
111 body: expr
112 globals: Optional[expr]
113 locals: Optional[expr]
114
115 class Global(stmt):
116 names: typing.List[_identifier]
117
118 class Expr(stmt):
119 value: expr
120
121 class Pass(stmt): ...
122 class Break(stmt): ...
123 class Continue(stmt): ...
124 class slice(AST): ...
125
126 _slice = slice # this lets us type the variable named 'slice' below
127
128 class Slice(slice):
129 lower: Optional[expr]
130 upper: Optional[expr]
131 step: Optional[expr]
132
133 class ExtSlice(slice):
134 dims: typing.List[slice]
135
136 class Index(slice):
137 value: expr
138
139 class Ellipsis(slice): ...
140
141 class expr(AST):
142 lineno: int
143 col_offset: int
144
145 class BoolOp(expr):
146 op: boolop
147 values: typing.List[expr]
148
149 class BinOp(expr):
150 left: expr
151 op: operator
152 right: expr
153
154 class UnaryOp(expr):
155 op: unaryop
156 operand: expr
157
158 class Lambda(expr):
159 args: arguments
160 body: expr
161
162 class IfExp(expr):
163 test: expr
164 body: expr
165 orelse: expr
166
167 class Dict(expr):
168 keys: typing.List[expr]
169 values: typing.List[expr]
170
171 class Set(expr):
172 elts: typing.List[expr]
173
174 class ListComp(expr):
175 elt: expr
176 generators: typing.List[comprehension]
177
178 class SetComp(expr):
179 elt: expr
180 generators: typing.List[comprehension]
181
182 class DictComp(expr):
183 key: expr
184 value: expr
185 generators: typing.List[comprehension]
186
187 class GeneratorExp(expr):
188 elt: expr
189 generators: typing.List[comprehension]
190
191 class Yield(expr):
192 value: Optional[expr]
193
194 class Compare(expr):
195 left: expr
196 ops: typing.List[cmpop]
197 comparators: typing.List[expr]
198
199 class Call(expr):
200 func: expr
201 args: typing.List[expr]
202 keywords: typing.List[keyword]
203 starargs: Optional[expr]
204 kwargs: Optional[expr]
205
206 class Repr(expr):
207 value: expr
208
209 class Num(expr):
210 n: float
211
212 class Str(expr):
213 s: str
214
215 class Attribute(expr):
216 value: expr
217 attr: _identifier
218 ctx: expr_context
219
220 class Subscript(expr):
221 value: expr
222 slice: _slice
223 ctx: expr_context
224
225 class Name(expr):
226 id: _identifier
227 ctx: expr_context
228
229 class List(expr):
230 elts: typing.List[expr]
231 ctx: expr_context
232
233 class Tuple(expr):
234 elts: typing.List[expr]
235 ctx: expr_context
236
237 class expr_context(AST): ...
238 class AugLoad(expr_context): ...
239 class AugStore(expr_context): ...
240 class Del(expr_context): ...
241 class Load(expr_context): ...
242 class Param(expr_context): ...
243 class Store(expr_context): ...
244 class boolop(AST): ...
245 class And(boolop): ...
246 class Or(boolop): ...
247 class operator(AST): ...
248 class Add(operator): ...
249 class BitAnd(operator): ...
250 class BitOr(operator): ...
251 class BitXor(operator): ...
252 class Div(operator): ...
253 class FloorDiv(operator): ...
254 class LShift(operator): ...
255 class Mod(operator): ...
256 class Mult(operator): ...
257 class Pow(operator): ...
258 class RShift(operator): ...
259 class Sub(operator): ...
260 class unaryop(AST): ...
261 class Invert(unaryop): ...
262 class Not(unaryop): ...
263 class UAdd(unaryop): ...
264 class USub(unaryop): ...
265 class cmpop(AST): ...
266 class Eq(cmpop): ...
267 class Gt(cmpop): ...
268 class GtE(cmpop): ...
269 class In(cmpop): ...
270 class Is(cmpop): ...
271 class IsNot(cmpop): ...
272 class Lt(cmpop): ...
273 class LtE(cmpop): ...
274 class NotEq(cmpop): ...
275 class NotIn(cmpop): ...
276
277 class comprehension(AST):
278 target: expr
279 iter: expr
280 ifs: typing.List[expr]
281
282 class excepthandler(AST): ...
283
284 class ExceptHandler(excepthandler):
285 type: Optional[expr]
286 name: Optional[expr]
287 body: typing.List[stmt]
288 lineno: int
289 col_offset: int
290
291 class arguments(AST):
292 args: typing.List[expr]
293 vararg: Optional[_identifier]
294 kwarg: Optional[_identifier]
295 defaults: typing.List[expr]
296
297 class keyword(AST):
298 arg: _identifier
299 value: expr
300
301 class alias(AST):
302 name: _identifier
303 asname: Optional[_identifier]
304