.config/coc/extensions/node_modules/coc-pyright/node_modules/pyright/dist/typeshed-fallback/stubs/typed-ast/typed_ast/ast27.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 = ...) -> 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 = ...) -> bytes | 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     type_comment: str | None
  62
  63 class ClassDef(stmt):
  64     name: identifier
  65     bases: list[expr]
  66     body: list[stmt]
  67     decorator_list: list[expr]
  68
  69 class Return(stmt):
  70     value: expr | None
  71
  72 class Delete(stmt):
  73     targets: list[expr]
  74
  75 class Assign(stmt):
  76     targets: list[expr]
  77     value: expr
  78     type_comment: str | None
  79
  80 class AugAssign(stmt):
  81     target: expr
  82     op: operator
  83     value: expr
  84
  85 class Print(stmt):
  86     dest: expr | None
  87     values: list[expr]
  88     nl: bool
  89
  90 class For(stmt):
  91     target: expr
  92     iter: expr
  93     body: list[stmt]
  94     orelse: list[stmt]
  95     type_comment: str | None
  96
  97 class While(stmt):
  98     test: expr
  99     body: list[stmt]
 100     orelse: list[stmt]
 101
 102 class If(stmt):
 103     test: expr
 104     body: list[stmt]
 105     orelse: list[stmt]
 106
 107 class With(stmt):
 108     context_expr: expr
 109     optional_vars: expr | None
 110     body: list[stmt]
 111     type_comment: str | None
 112
 113 class Raise(stmt):
 114     type: expr | None
 115     inst: expr | None
 116     tback: expr | None
 117
 118 class TryExcept(stmt):
 119     body: list[stmt]
 120     handlers: list[ExceptHandler]
 121     orelse: list[stmt]
 122
 123 class TryFinally(stmt):
 124     body: list[stmt]
 125     finalbody: list[stmt]
 126
 127 class Assert(stmt):
 128     test: expr
 129     msg: expr | None
 130
 131 class Import(stmt):
 132     names: list[alias]
 133
 134 class ImportFrom(stmt):
 135     module: identifier | None
 136     names: list[alias]
 137     level: int | None
 138
 139 class Exec(stmt):
 140     body: expr
 141     globals: expr | None
 142     locals: expr | None
 143
 144 class Global(stmt):
 145     names: list[identifier]
 146
 147 class Expr(stmt):
 148     value: expr
 149
 150 class Pass(stmt): ...
 151 class Break(stmt): ...
 152 class Continue(stmt): ...
 153 class slice(AST): ...
 154
 155 _slice = slice  # this lets us type the variable named 'slice' below
 156
 157 class Slice(slice):
 158     lower: expr | None
 159     upper: expr | None
 160     step: expr | None
 161
 162 class ExtSlice(slice):
 163     dims: list[slice]
 164
 165 class Index(slice):
 166     value: expr
 167
 168 class Ellipsis(slice): ...
 169
 170 class expr(AST):
 171     lineno: int
 172     col_offset: int
 173
 174 class BoolOp(expr):
 175     op: boolop
 176     values: list[expr]
 177
 178 class BinOp(expr):
 179     left: expr
 180     op: operator
 181     right: expr
 182
 183 class UnaryOp(expr):
 184     op: unaryop
 185     operand: expr
 186
 187 class Lambda(expr):
 188     args: arguments
 189     body: expr
 190
 191 class IfExp(expr):
 192     test: expr
 193     body: expr
 194     orelse: expr
 195
 196 class Dict(expr):
 197     keys: list[expr]
 198     values: list[expr]
 199
 200 class Set(expr):
 201     elts: list[expr]
 202
 203 class ListComp(expr):
 204     elt: expr
 205     generators: list[comprehension]
 206
 207 class SetComp(expr):
 208     elt: expr
 209     generators: list[comprehension]
 210
 211 class DictComp(expr):
 212     key: expr
 213     value: expr
 214     generators: list[comprehension]
 215
 216 class GeneratorExp(expr):
 217     elt: expr
 218     generators: list[comprehension]
 219
 220 class Yield(expr):
 221     value: expr | None
 222
 223 class Compare(expr):
 224     left: expr
 225     ops: list[cmpop]
 226     comparators: list[expr]
 227
 228 class Call(expr):
 229     func: expr
 230     args: list[expr]
 231     keywords: list[keyword]
 232     starargs: expr | None
 233     kwargs: expr | None
 234
 235 class Repr(expr):
 236     value: expr
 237
 238 class Num(expr):
 239     n: int | float | complex
 240
 241 class Str(expr):
 242     s: str | bytes
 243     kind: str
 244
 245 class Attribute(expr):
 246     value: expr
 247     attr: identifier
 248     ctx: expr_context
 249
 250 class Subscript(expr):
 251     value: expr
 252     slice: _slice
 253     ctx: expr_context
 254
 255 class Name(expr):
 256     id: identifier
 257     ctx: expr_context
 258
 259 class List(expr):
 260     elts: list[expr]
 261     ctx: expr_context
 262
 263 class Tuple(expr):
 264     elts: list[expr]
 265     ctx: expr_context
 266
 267 class expr_context(AST): ...
 268 class AugLoad(expr_context): ...
 269 class AugStore(expr_context): ...
 270 class Del(expr_context): ...
 271 class Load(expr_context): ...
 272 class Param(expr_context): ...
 273 class Store(expr_context): ...
 274 class boolop(AST): ...
 275 class And(boolop): ...
 276 class Or(boolop): ...
 277 class operator(AST): ...
 278 class Add(operator): ...
 279 class BitAnd(operator): ...
 280 class BitOr(operator): ...
 281 class BitXor(operator): ...
 282 class Div(operator): ...
 283 class FloorDiv(operator): ...
 284 class LShift(operator): ...
 285 class Mod(operator): ...
 286 class Mult(operator): ...
 287 class Pow(operator): ...
 288 class RShift(operator): ...
 289 class Sub(operator): ...
 290 class unaryop(AST): ...
 291 class Invert(unaryop): ...
 292 class Not(unaryop): ...
 293 class UAdd(unaryop): ...
 294 class USub(unaryop): ...
 295 class cmpop(AST): ...
 296 class Eq(cmpop): ...
 297 class Gt(cmpop): ...
 298 class GtE(cmpop): ...
 299 class In(cmpop): ...
 300 class Is(cmpop): ...
 301 class IsNot(cmpop): ...
 302 class Lt(cmpop): ...
 303 class LtE(cmpop): ...
 304 class NotEq(cmpop): ...
 305 class NotIn(cmpop): ...
 306
 307 class comprehension(AST):
 308     target: expr
 309     iter: expr
 310     ifs: list[expr]
 311
 312 class ExceptHandler(AST):
 313     type: expr | None
 314     name: expr | None
 315     body: list[stmt]
 316     lineno: int
 317     col_offset: int
 318
 319 class arguments(AST):
 320     args: list[expr]
 321     vararg: identifier | None
 322     kwarg: identifier | None
 323     defaults: list[expr]
 324     type_comments: list[str | None]
 325
 326 class keyword(AST):
 327     arg: identifier
 328     value: expr
 329
 330 class alias(AST):
 331     name: identifier
 332     asname: identifier | None
 333
 334 class TypeIgnore(AST):
 335     lineno: int