--- /dev/null
+import sys
+import typing
+from typing import Any, ClassVar
+from typing_extensions import Literal
+
+PyCF_ONLY_AST: int
+if sys.version_info >= (3, 8):
+ PyCF_TYPE_COMMENTS: int
+ PyCF_ALLOW_TOP_LEVEL_AWAIT: int
+
+_identifier = str
+
+class AST:
+ _attributes: ClassVar[typing.Tuple[str, ...]]
+ _fields: ClassVar[typing.Tuple[str, ...]]
+ def __init__(self, *args: Any, **kwargs: Any) -> None: ...
+ # TODO: Not all nodes have all of the following attributes
+ lineno: int
+ col_offset: int
+ if sys.version_info >= (3, 8):
+ end_lineno: int | None
+ end_col_offset: int | None
+ type_comment: str | None
+
+class mod(AST): ...
+
+if sys.version_info >= (3, 8):
+ class type_ignore(AST): ...
+ class TypeIgnore(type_ignore):
+ tag: str
+ class FunctionType(mod):
+ argtypes: list[expr]
+ returns: expr
+
+class Module(mod):
+ body: list[stmt]
+ if sys.version_info >= (3, 8):
+ type_ignores: list[TypeIgnore]
+
+class Interactive(mod):
+ body: list[stmt]
+
+class Expression(mod):
+ body: expr
+
+class stmt(AST): ...
+
+class FunctionDef(stmt):
+ name: _identifier
+ args: arguments
+ body: list[stmt]
+ decorator_list: list[expr]
+ returns: expr | None
+
+class AsyncFunctionDef(stmt):
+ name: _identifier
+ args: arguments
+ body: list[stmt]
+ decorator_list: list[expr]
+ returns: expr | None
+
+class ClassDef(stmt):
+ name: _identifier
+ bases: list[expr]
+ keywords: list[keyword]
+ body: list[stmt]
+ decorator_list: list[expr]
+
+class Return(stmt):
+ value: expr | None
+
+class Delete(stmt):
+ targets: list[expr]
+
+class Assign(stmt):
+ targets: list[expr]
+ value: expr
+
+class AugAssign(stmt):
+ target: expr
+ op: operator
+ value: expr
+
+class AnnAssign(stmt):
+ target: expr
+ annotation: expr
+ value: expr | None
+ simple: int
+
+class For(stmt):
+ target: expr
+ iter: expr
+ body: list[stmt]
+ orelse: list[stmt]
+
+class AsyncFor(stmt):
+ target: expr
+ iter: expr
+ body: list[stmt]
+ orelse: list[stmt]
+
+class While(stmt):
+ test: expr
+ body: list[stmt]
+ orelse: list[stmt]
+
+class If(stmt):
+ test: expr
+ body: list[stmt]
+ orelse: list[stmt]
+
+class With(stmt):
+ items: list[withitem]
+ body: list[stmt]
+
+class AsyncWith(stmt):
+ items: list[withitem]
+ body: list[stmt]
+
+class Raise(stmt):
+ exc: expr | None
+ cause: expr | None
+
+class Try(stmt):
+ body: list[stmt]
+ handlers: list[ExceptHandler]
+ orelse: list[stmt]
+ finalbody: list[stmt]
+
+class Assert(stmt):
+ test: expr
+ msg: expr | None
+
+class Import(stmt):
+ names: list[alias]
+
+class ImportFrom(stmt):
+ module: _identifier | None
+ names: list[alias]
+ level: int
+
+class Global(stmt):
+ names: list[_identifier]
+
+class Nonlocal(stmt):
+ names: list[_identifier]
+
+class Expr(stmt):
+ value: expr
+
+class Pass(stmt): ...
+class Break(stmt): ...
+class Continue(stmt): ...
+class expr(AST): ...
+
+class BoolOp(expr):
+ op: boolop
+ values: list[expr]
+
+class BinOp(expr):
+ left: expr
+ op: operator
+ right: expr
+
+class UnaryOp(expr):
+ op: unaryop
+ operand: expr
+
+class Lambda(expr):
+ args: arguments
+ body: expr
+
+class IfExp(expr):
+ test: expr
+ body: expr
+ orelse: expr
+
+class Dict(expr):
+ keys: list[expr | None]
+ values: list[expr]
+
+class Set(expr):
+ elts: list[expr]
+
+class ListComp(expr):
+ elt: expr
+ generators: list[comprehension]
+
+class SetComp(expr):
+ elt: expr
+ generators: list[comprehension]
+
+class DictComp(expr):
+ key: expr
+ value: expr
+ generators: list[comprehension]
+
+class GeneratorExp(expr):
+ elt: expr
+ generators: list[comprehension]
+
+class Await(expr):
+ value: expr
+
+class Yield(expr):
+ value: expr | None
+
+class YieldFrom(expr):
+ value: expr
+
+class Compare(expr):
+ left: expr
+ ops: list[cmpop]
+ comparators: list[expr]
+
+class Call(expr):
+ func: expr
+ args: list[expr]
+ keywords: list[keyword]
+
+class FormattedValue(expr):
+ value: expr
+ conversion: int | None
+ format_spec: expr | None
+
+class JoinedStr(expr):
+ values: list[expr]
+
+if sys.version_info < (3, 8):
+ class Num(expr): # Deprecated in 3.8; use Constant
+ n: complex
+ class Str(expr): # Deprecated in 3.8; use Constant
+ s: str
+ class Bytes(expr): # Deprecated in 3.8; use Constant
+ s: bytes
+ class NameConstant(expr): # Deprecated in 3.8; use Constant
+ value: Any
+ class Ellipsis(expr): ... # Deprecated in 3.8; use Constant
+
+class Constant(expr):
+ value: Any # None, str, bytes, bool, int, float, complex, Ellipsis
+ kind: str | None
+ # Aliases for value, for backwards compatibility
+ s: Any
+ n: complex
+
+if sys.version_info >= (3, 8):
+ class NamedExpr(expr):
+ target: expr
+ value: expr
+
+class Attribute(expr):
+ value: expr
+ attr: _identifier
+ ctx: expr_context
+
+if sys.version_info >= (3, 9):
+ _SliceT = expr
+else:
+ class slice(AST): ...
+ _SliceT = slice
+
+class Slice(_SliceT):
+ lower: expr | None
+ upper: expr | None
+ step: expr | None
+
+if sys.version_info < (3, 9):
+ class ExtSlice(slice):
+ dims: list[slice]
+ class Index(slice):
+ value: expr
+
+class Subscript(expr):
+ value: expr
+ slice: _SliceT
+ ctx: expr_context
+
+class Starred(expr):
+ value: expr
+ ctx: expr_context
+
+class Name(expr):
+ id: _identifier
+ ctx: expr_context
+
+class List(expr):
+ elts: list[expr]
+ ctx: expr_context
+
+class Tuple(expr):
+ elts: list[expr]
+ ctx: expr_context
+
+class expr_context(AST): ...
+
+if sys.version_info < (3, 9):
+ class AugLoad(expr_context): ...
+ class AugStore(expr_context): ...
+ class Param(expr_context): ...
+ class Suite(mod):
+ body: list[stmt]
+
+class Del(expr_context): ...
+class Load(expr_context): ...
+class Store(expr_context): ...
+class boolop(AST): ...
+class And(boolop): ...
+class Or(boolop): ...
+class operator(AST): ...
+class Add(operator): ...
+class BitAnd(operator): ...
+class BitOr(operator): ...
+class BitXor(operator): ...
+class Div(operator): ...
+class FloorDiv(operator): ...
+class LShift(operator): ...
+class Mod(operator): ...
+class Mult(operator): ...
+class MatMult(operator): ...
+class Pow(operator): ...
+class RShift(operator): ...
+class Sub(operator): ...
+class unaryop(AST): ...
+class Invert(unaryop): ...
+class Not(unaryop): ...
+class UAdd(unaryop): ...
+class USub(unaryop): ...
+class cmpop(AST): ...
+class Eq(cmpop): ...
+class Gt(cmpop): ...
+class GtE(cmpop): ...
+class In(cmpop): ...
+class Is(cmpop): ...
+class IsNot(cmpop): ...
+class Lt(cmpop): ...
+class LtE(cmpop): ...
+class NotEq(cmpop): ...
+class NotIn(cmpop): ...
+
+class comprehension(AST):
+ target: expr
+ iter: expr
+ ifs: list[expr]
+ is_async: int
+
+class excepthandler(AST): ...
+
+class ExceptHandler(excepthandler):
+ type: expr | None
+ name: _identifier | None
+ body: list[stmt]
+
+class arguments(AST):
+ if sys.version_info >= (3, 8):
+ posonlyargs: list[arg]
+ args: list[arg]
+ vararg: arg | None
+ kwonlyargs: list[arg]
+ kw_defaults: list[expr | None]
+ kwarg: arg | None
+ defaults: list[expr]
+
+class arg(AST):
+ arg: _identifier
+ annotation: expr | None
+
+class keyword(AST):
+ arg: _identifier | None
+ value: expr
+
+class alias(AST):
+ name: _identifier
+ asname: _identifier | None
+
+class withitem(AST):
+ context_expr: expr
+ optional_vars: expr | None
+
+if sys.version_info >= (3, 10):
+ class Match(stmt):
+ subject: expr
+ cases: list[match_case]
+ class pattern(AST): ...
+ # Without the alias, Pyright complains variables named pattern are recursively defined
+ _pattern = pattern
+ class match_case(AST):
+ pattern: _pattern
+ guard: expr | None
+ body: list[stmt]
+ class MatchValue(pattern):
+ value: expr
+ class MatchSingleton(pattern):
+ value: Literal[True, False, None]
+ class MatchSequence(pattern):
+ patterns: list[pattern]
+ class MatchStar(pattern):
+ name: _identifier | None
+ class MatchMapping(pattern):
+ keys: list[expr]
+ patterns: list[pattern]
+ rest: _identifier | None
+ class MatchClass(pattern):
+ cls: expr
+ patterns: list[pattern]
+ kwd_attrs: list[_identifier]
+ kwd_patterns: list[pattern]
+ class MatchAs(pattern):
+ pattern: _pattern | None
+ name: _identifier | None
+ class MatchOr(pattern):
+ patterns: list[pattern]
projects / dotfiles / .git / blobdiff