.config/coc/extensions/node_modules/coc-pyright/node_modules/pyright/dist/typeshed-fallback/stdlib/_ast.pyi

   1 import sys
   2 import typing
   3 from typing import Any, ClassVar
   4 from typing_extensions import Literal
   5
   6 PyCF_ONLY_AST: int
   7 if sys.version_info >= (3, 8):
   8     PyCF_TYPE_COMMENTS: int
   9     PyCF_ALLOW_TOP_LEVEL_AWAIT: int
  10
  11 _identifier = str
  12
  13 class AST:
  14     _attributes: ClassVar[typing.Tuple[str, ...]]
  15     _fields: ClassVar[typing.Tuple[str, ...]]
  16     def __init__(self, *args: Any, **kwargs: Any) -> None: ...
  17     # TODO: Not all nodes have all of the following attributes
  18     lineno: int
  19     col_offset: int
  20     if sys.version_info >= (3, 8):
  21         end_lineno: int | None
  22         end_col_offset: int | None
  23         type_comment: str | None
  24
  25 class mod(AST): ...
  26
  27 if sys.version_info >= (3, 8):
  28     class type_ignore(AST): ...
  29     class TypeIgnore(type_ignore):
  30         tag: str
  31     class FunctionType(mod):
  32         argtypes: list[expr]
  33         returns: expr
  34
  35 class Module(mod):
  36     body: list[stmt]
  37     if sys.version_info >= (3, 8):
  38         type_ignores: list[TypeIgnore]
  39
  40 class Interactive(mod):
  41     body: list[stmt]
  42
  43 class Expression(mod):
  44     body: expr
  45
  46 class stmt(AST): ...
  47
  48 class FunctionDef(stmt):
  49     name: _identifier
  50     args: arguments
  51     body: list[stmt]
  52     decorator_list: list[expr]
  53     returns: expr | None
  54
  55 class AsyncFunctionDef(stmt):
  56     name: _identifier
  57     args: arguments
  58     body: list[stmt]
  59     decorator_list: list[expr]
  60     returns: expr | None
  61
  62 class ClassDef(stmt):
  63     name: _identifier
  64     bases: list[expr]
  65     keywords: list[keyword]
  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
  79 class AugAssign(stmt):
  80     target: expr
  81     op: operator
  82     value: expr
  83
  84 class AnnAssign(stmt):
  85     target: expr
  86     annotation: expr
  87     value: expr | None
  88     simple: int
  89
  90 class For(stmt):
  91     target: expr
  92     iter: expr
  93     body: list[stmt]
  94     orelse: list[stmt]
  95
  96 class AsyncFor(stmt):
  97     target: expr
  98     iter: expr
  99     body: list[stmt]
 100     orelse: list[stmt]
 101
 102 class While(stmt):
 103     test: expr
 104     body: list[stmt]
 105     orelse: list[stmt]
 106
 107 class If(stmt):
 108     test: expr
 109     body: list[stmt]
 110     orelse: list[stmt]
 111
 112 class With(stmt):
 113     items: list[withitem]
 114     body: list[stmt]
 115
 116 class AsyncWith(stmt):
 117     items: list[withitem]
 118     body: list[stmt]
 119
 120 class Raise(stmt):
 121     exc: expr | None
 122     cause: expr | None
 123
 124 class Try(stmt):
 125     body: list[stmt]
 126     handlers: list[ExceptHandler]
 127     orelse: list[stmt]
 128     finalbody: list[stmt]
 129
 130 class Assert(stmt):
 131     test: expr
 132     msg: expr | None
 133
 134 class Import(stmt):
 135     names: list[alias]
 136
 137 class ImportFrom(stmt):
 138     module: _identifier | None
 139     names: list[alias]
 140     level: int
 141
 142 class Global(stmt):
 143     names: list[_identifier]
 144
 145 class Nonlocal(stmt):
 146     names: list[_identifier]
 147
 148 class Expr(stmt):
 149     value: expr
 150
 151 class Pass(stmt): ...
 152 class Break(stmt): ...
 153 class Continue(stmt): ...
 154 class expr(AST): ...
 155
 156 class BoolOp(expr):
 157     op: boolop
 158     values: list[expr]
 159
 160 class BinOp(expr):
 161     left: expr
 162     op: operator
 163     right: expr
 164
 165 class UnaryOp(expr):
 166     op: unaryop
 167     operand: expr
 168
 169 class Lambda(expr):
 170     args: arguments
 171     body: expr
 172
 173 class IfExp(expr):
 174     test: expr
 175     body: expr
 176     orelse: expr
 177
 178 class Dict(expr):
 179     keys: list[expr | None]
 180     values: list[expr]
 181
 182 class Set(expr):
 183     elts: list[expr]
 184
 185 class ListComp(expr):
 186     elt: expr
 187     generators: list[comprehension]
 188
 189 class SetComp(expr):
 190     elt: expr
 191     generators: list[comprehension]
 192
 193 class DictComp(expr):
 194     key: expr
 195     value: expr
 196     generators: list[comprehension]
 197
 198 class GeneratorExp(expr):
 199     elt: expr
 200     generators: list[comprehension]
 201
 202 class Await(expr):
 203     value: expr
 204
 205 class Yield(expr):
 206     value: expr | None
 207
 208 class YieldFrom(expr):
 209     value: expr
 210
 211 class Compare(expr):
 212     left: expr
 213     ops: list[cmpop]
 214     comparators: list[expr]
 215
 216 class Call(expr):
 217     func: expr
 218     args: list[expr]
 219     keywords: list[keyword]
 220
 221 class FormattedValue(expr):
 222     value: expr
 223     conversion: int | None
 224     format_spec: expr | None
 225
 226 class JoinedStr(expr):
 227     values: list[expr]
 228
 229 if sys.version_info < (3, 8):
 230     class Num(expr):  # Deprecated in 3.8; use Constant
 231         n: complex
 232     class Str(expr):  # Deprecated in 3.8; use Constant
 233         s: str
 234     class Bytes(expr):  # Deprecated in 3.8; use Constant
 235         s: bytes
 236     class NameConstant(expr):  # Deprecated in 3.8; use Constant
 237         value: Any
 238     class Ellipsis(expr): ...  # Deprecated in 3.8; use Constant
 239
 240 class Constant(expr):
 241     value: Any  # None, str, bytes, bool, int, float, complex, Ellipsis
 242     kind: str | None
 243     # Aliases for value, for backwards compatibility
 244     s: Any
 245     n: complex
 246
 247 if sys.version_info >= (3, 8):
 248     class NamedExpr(expr):
 249         target: expr
 250         value: expr
 251
 252 class Attribute(expr):
 253     value: expr
 254     attr: _identifier
 255     ctx: expr_context
 256
 257 if sys.version_info >= (3, 9):
 258     _SliceT = expr
 259 else:
 260     class slice(AST): ...
 261     _SliceT = slice
 262
 263 class Slice(_SliceT):
 264     lower: expr | None
 265     upper: expr | None
 266     step: expr | None
 267
 268 if sys.version_info < (3, 9):
 269     class ExtSlice(slice):
 270         dims: list[slice]
 271     class Index(slice):
 272         value: expr
 273
 274 class Subscript(expr):
 275     value: expr
 276     slice: _SliceT
 277     ctx: expr_context
 278
 279 class Starred(expr):
 280     value: expr
 281     ctx: expr_context
 282
 283 class Name(expr):
 284     id: _identifier
 285     ctx: expr_context
 286
 287 class List(expr):
 288     elts: list[expr]
 289     ctx: expr_context
 290
 291 class Tuple(expr):
 292     elts: list[expr]
 293     ctx: expr_context
 294
 295 class expr_context(AST): ...
 296
 297 if sys.version_info < (3, 9):
 298     class AugLoad(expr_context): ...
 299     class AugStore(expr_context): ...
 300     class Param(expr_context): ...
 301     class Suite(mod):
 302         body: list[stmt]
 303
 304 class Del(expr_context): ...
 305 class Load(expr_context): ...
 306 class Store(expr_context): ...
 307 class boolop(AST): ...
 308 class And(boolop): ...
 309 class Or(boolop): ...
 310 class operator(AST): ...
 311 class Add(operator): ...
 312 class BitAnd(operator): ...
 313 class BitOr(operator): ...
 314 class BitXor(operator): ...
 315 class Div(operator): ...
 316 class FloorDiv(operator): ...
 317 class LShift(operator): ...
 318 class Mod(operator): ...
 319 class Mult(operator): ...
 320 class MatMult(operator): ...
 321 class Pow(operator): ...
 322 class RShift(operator): ...
 323 class Sub(operator): ...
 324 class unaryop(AST): ...
 325 class Invert(unaryop): ...
 326 class Not(unaryop): ...
 327 class UAdd(unaryop): ...
 328 class USub(unaryop): ...
 329 class cmpop(AST): ...
 330 class Eq(cmpop): ...
 331 class Gt(cmpop): ...
 332 class GtE(cmpop): ...
 333 class In(cmpop): ...
 334 class Is(cmpop): ...
 335 class IsNot(cmpop): ...
 336 class Lt(cmpop): ...
 337 class LtE(cmpop): ...
 338 class NotEq(cmpop): ...
 339 class NotIn(cmpop): ...
 340
 341 class comprehension(AST):
 342     target: expr
 343     iter: expr
 344     ifs: list[expr]
 345     is_async: int
 346
 347 class excepthandler(AST): ...
 348
 349 class ExceptHandler(excepthandler):
 350     type: expr | None
 351     name: _identifier | None
 352     body: list[stmt]
 353
 354 class arguments(AST):
 355     if sys.version_info >= (3, 8):
 356         posonlyargs: list[arg]
 357     args: list[arg]
 358     vararg: arg | None
 359     kwonlyargs: list[arg]
 360     kw_defaults: list[expr | None]
 361     kwarg: arg | None
 362     defaults: list[expr]
 363
 364 class arg(AST):
 365     arg: _identifier
 366     annotation: expr | None
 367
 368 class keyword(AST):
 369     arg: _identifier | None
 370     value: expr
 371
 372 class alias(AST):
 373     name: _identifier
 374     asname: _identifier | None
 375
 376 class withitem(AST):
 377     context_expr: expr
 378     optional_vars: expr | None
 379
 380 if sys.version_info >= (3, 10):
 381     class Match(stmt):
 382         subject: expr
 383         cases: list[match_case]
 384     class pattern(AST): ...
 385     # Without the alias, Pyright complains variables named pattern are recursively defined
 386     _pattern = pattern
 387     class match_case(AST):
 388         pattern: _pattern
 389         guard: expr | None
 390         body: list[stmt]
 391     class MatchValue(pattern):
 392         value: expr
 393     class MatchSingleton(pattern):
 394         value: Literal[True, False, None]
 395     class MatchSequence(pattern):
 396         patterns: list[pattern]
 397     class MatchStar(pattern):
 398         name: _identifier | None
 399     class MatchMapping(pattern):
 400         keys: list[expr]
 401         patterns: list[pattern]
 402         rest: _identifier | None
 403     class MatchClass(pattern):
 404         cls: expr
 405         patterns: list[pattern]
 406         kwd_attrs: list[_identifier]
 407         kwd_patterns: list[pattern]
 408     class MatchAs(pattern):
 409         pattern: _pattern | None
 410         name: _identifier | None
 411     class MatchOr(pattern):
 412         patterns: list[pattern]