.config/coc/extensions/node_modules/coc-pyright/node_modules/pyright/dist/typeshed-fallback/stubs/typed-ast/typed_ast/ast3.pyi

   1 import typing
   2 from typing import Any, Iterator
   3
   4 class NodeVisitor:
   5     def visit(self, node: AST) -> Any: ...
   6     def generic_visit(self, node: AST) -> None: ...
   7
   8 class NodeTransformer(NodeVisitor):
   9     def generic_visit(self, node: AST) -> None: ...
  10
  11 def parse(source: str | bytes, filename: str | bytes = ..., mode: str = ..., feature_version: int = ...) -> AST: ...
  12 def copy_location(new_node: AST, old_node: AST) -> AST: ...
  13 def dump(node: AST, annotate_fields: bool = ..., include_attributes: bool = ...) -> str: ...
  14 def fix_missing_locations(node: AST) -> AST: ...
  15 def get_docstring(node: AST, clean: bool = ...) -> str | None: ...
  16 def increment_lineno(node: AST, n: int = ...) -> AST: ...
  17 def iter_child_nodes(node: AST) -> Iterator[AST]: ...
  18 def iter_fields(node: AST) -> Iterator[typing.Tuple[str, Any]]: ...
  19 def literal_eval(node_or_string: str | AST) -> Any: ...
  20 def walk(node: AST) -> Iterator[AST]: ...
  21
  22 PyCF_ONLY_AST: int
  23
  24 # ast classes
  25
  26 identifier = str
  27
  28 class AST:
  29     _attributes: typing.Tuple[str, ...]
  30     _fields: typing.Tuple[str, ...]
  31     def __init__(self, *args: Any, **kwargs: Any) -> None: ...
  32
  33 class mod(AST): ...
  34
  35 class Module(mod):
  36     body: list[stmt]
  37     type_ignores: list[TypeIgnore]
  38
  39 class Interactive(mod):
  40     body: list[stmt]
  41
  42 class Expression(mod):
  43     body: expr
  44
  45 class FunctionType(mod):
  46     argtypes: list[expr]
  47     returns: expr
  48
  49 class Suite(mod):
  50     body: list[stmt]
  51
  52 class stmt(AST):
  53     lineno: int
  54     col_offset: int
  55
  56 class FunctionDef(stmt):
  57     name: identifier
  58     args: arguments
  59     body: list[stmt]
  60     decorator_list: list[expr]
  61     returns: expr | None
  62     type_comment: str | None
  63
  64 class AsyncFunctionDef(stmt):
  65     name: identifier
  66     args: arguments
  67     body: list[stmt]
  68     decorator_list: list[expr]
  69     returns: expr | None
  70     type_comment: str | None
  71
  72 class ClassDef(stmt):
  73     name: identifier
  74     bases: list[expr]
  75     keywords: list[keyword]
  76     body: list[stmt]
  77     decorator_list: list[expr]
  78
  79 class Return(stmt):
  80     value: expr | None
  81
  82 class Delete(stmt):
  83     targets: list[expr]
  84
  85 class Assign(stmt):
  86     targets: list[expr]
  87     value: expr
  88     type_comment: str | None
  89
  90 class AugAssign(stmt):
  91     target: expr
  92     op: operator
  93     value: expr
  94
  95 class AnnAssign(stmt):
  96     target: expr
  97     annotation: expr
  98     value: expr | None
  99     simple: int
 100
 101 class For(stmt):
 102     target: expr
 103     iter: expr
 104     body: list[stmt]
 105     orelse: list[stmt]
 106     type_comment: str | None
 107
 108 class AsyncFor(stmt):
 109     target: expr
 110     iter: expr
 111     body: list[stmt]
 112     orelse: list[stmt]
 113     type_comment: str | None
 114
 115 class While(stmt):
 116     test: expr
 117     body: list[stmt]
 118     orelse: list[stmt]
 119
 120 class If(stmt):
 121     test: expr
 122     body: list[stmt]
 123     orelse: list[stmt]
 124
 125 class With(stmt):
 126     items: list[withitem]
 127     body: list[stmt]
 128     type_comment: str | None
 129
 130 class AsyncWith(stmt):
 131     items: list[withitem]
 132     body: list[stmt]
 133     type_comment: str | None
 134
 135 class Raise(stmt):
 136     exc: expr | None
 137     cause: expr | None
 138
 139 class Try(stmt):
 140     body: list[stmt]
 141     handlers: list[ExceptHandler]
 142     orelse: list[stmt]
 143     finalbody: list[stmt]
 144
 145 class Assert(stmt):
 146     test: expr
 147     msg: expr | None
 148
 149 class Import(stmt):
 150     names: list[alias]
 151
 152 class ImportFrom(stmt):
 153     module: identifier | None
 154     names: list[alias]
 155     level: int | None
 156
 157 class Global(stmt):
 158     names: list[identifier]
 159
 160 class Nonlocal(stmt):
 161     names: list[identifier]
 162
 163 class Expr(stmt):
 164     value: expr
 165
 166 class Pass(stmt): ...
 167 class Break(stmt): ...
 168 class Continue(stmt): ...
 169 class slice(AST): ...
 170
 171 _slice = slice  # this lets us type the variable named 'slice' below
 172
 173 class Slice(slice):
 174     lower: expr | None
 175     upper: expr | None
 176     step: expr | None
 177
 178 class ExtSlice(slice):
 179     dims: list[slice]
 180
 181 class Index(slice):
 182     value: expr
 183
 184 class expr(AST):
 185     lineno: int
 186     col_offset: int
 187
 188 class BoolOp(expr):
 189     op: boolop
 190     values: list[expr]
 191
 192 class BinOp(expr):
 193     left: expr
 194     op: operator
 195     right: expr
 196
 197 class UnaryOp(expr):
 198     op: unaryop
 199     operand: expr
 200
 201 class Lambda(expr):
 202     args: arguments
 203     body: expr
 204
 205 class IfExp(expr):
 206     test: expr
 207     body: expr
 208     orelse: expr
 209
 210 class Dict(expr):
 211     keys: list[expr]
 212     values: list[expr]
 213
 214 class Set(expr):
 215     elts: list[expr]
 216
 217 class ListComp(expr):
 218     elt: expr
 219     generators: list[comprehension]
 220
 221 class SetComp(expr):
 222     elt: expr
 223     generators: list[comprehension]
 224
 225 class DictComp(expr):
 226     key: expr
 227     value: expr
 228     generators: list[comprehension]
 229
 230 class GeneratorExp(expr):
 231     elt: expr
 232     generators: list[comprehension]
 233
 234 class Await(expr):
 235     value: expr
 236
 237 class Yield(expr):
 238     value: expr | None
 239
 240 class YieldFrom(expr):
 241     value: expr
 242
 243 class Compare(expr):
 244     left: expr
 245     ops: list[cmpop]
 246     comparators: list[expr]
 247
 248 class Call(expr):
 249     func: expr
 250     args: list[expr]
 251     keywords: list[keyword]
 252
 253 class Num(expr):
 254     n: float | int | complex
 255
 256 class Str(expr):
 257     s: str
 258     kind: str
 259
 260 class FormattedValue(expr):
 261     value: expr
 262     conversion: int | None
 263     format_spec: expr | None
 264
 265 class JoinedStr(expr):
 266     values: list[expr]
 267
 268 class Bytes(expr):
 269     s: bytes
 270
 271 class NameConstant(expr):
 272     value: Any
 273
 274 class Ellipsis(expr): ...
 275
 276 class Attribute(expr):
 277     value: expr
 278     attr: identifier
 279     ctx: expr_context
 280
 281 class Subscript(expr):
 282     value: expr
 283     slice: _slice
 284     ctx: expr_context
 285
 286 class Starred(expr):
 287     value: expr
 288     ctx: expr_context
 289
 290 class Name(expr):
 291     id: identifier
 292     ctx: expr_context
 293
 294 class List(expr):
 295     elts: list[expr]
 296     ctx: expr_context
 297
 298 class Tuple(expr):
 299     elts: list[expr]
 300     ctx: expr_context
 301
 302 class expr_context(AST): ...
 303 class AugLoad(expr_context): ...
 304 class AugStore(expr_context): ...
 305 class Del(expr_context): ...
 306 class Load(expr_context): ...
 307 class Param(expr_context): ...
 308 class Store(expr_context): ...
 309 class boolop(AST): ...
 310 class And(boolop): ...
 311 class Or(boolop): ...
 312 class operator(AST): ...
 313 class Add(operator): ...
 314 class BitAnd(operator): ...
 315 class BitOr(operator): ...
 316 class BitXor(operator): ...
 317 class Div(operator): ...
 318 class FloorDiv(operator): ...
 319 class LShift(operator): ...
 320 class Mod(operator): ...
 321 class Mult(operator): ...
 322 class MatMult(operator): ...
 323 class Pow(operator): ...
 324 class RShift(operator): ...
 325 class Sub(operator): ...
 326 class unaryop(AST): ...
 327 class Invert(unaryop): ...
 328 class Not(unaryop): ...
 329 class UAdd(unaryop): ...
 330 class USub(unaryop): ...
 331 class cmpop(AST): ...
 332 class Eq(cmpop): ...
 333 class Gt(cmpop): ...
 334 class GtE(cmpop): ...
 335 class In(cmpop): ...
 336 class Is(cmpop): ...
 337 class IsNot(cmpop): ...
 338 class Lt(cmpop): ...
 339 class LtE(cmpop): ...
 340 class NotEq(cmpop): ...
 341 class NotIn(cmpop): ...
 342
 343 class comprehension(AST):
 344     target: expr
 345     iter: expr
 346     ifs: list[expr]
 347     is_async: int
 348
 349 class ExceptHandler(AST):
 350     type: expr | None
 351     name: identifier | None
 352     body: list[stmt]
 353     lineno: int
 354     col_offset: int
 355
 356 class arguments(AST):
 357     args: list[arg]
 358     vararg: arg | None
 359     kwonlyargs: list[arg]
 360     kw_defaults: list[expr]
 361     kwarg: arg | None
 362     defaults: list[expr]
 363
 364 class arg(AST):
 365     arg: identifier
 366     annotation: expr | None
 367     lineno: int
 368     col_offset: int
 369     type_comment: str | None
 370
 371 class keyword(AST):
 372     arg: identifier | None
 373     value: expr
 374
 375 class alias(AST):
 376     name: identifier
 377     asname: identifier | None
 378
 379 class withitem(AST):
 380     context_expr: expr
 381     optional_vars: expr | None
 382
 383 class TypeIgnore(AST):
 384     lineno: int