Python AST Nodes

The module is great!

wast.nodes.to_builtin(node: Node) → AST

wast.nodes.from_builtin(node: AST) → Node

class wast.nodes.mod

Bases: Node

class wast.nodes.Module(body=NOTHING, type_ignores=NOTHING)

Bases: mod

body: Sequence[stmt]

type_ignores: Sequence[type_ignore]

class wast.nodes.Interactive(body=NOTHING)

Bases: mod

body: Sequence[stmt]

class wast.nodes.Expression(body: w.WrappedNode | w.Node)

Bases: mod

body: expr

class wast.nodes.FunctionType(returns: w.WrappedNode | w.Node, argtypes=NOTHING)

Bases: mod

returns: expr

argtypes: Sequence[expr]

class wast.nodes.stmt

Bases: Node

class wast.nodes.FunctionDef(args: w.WrappedNode | w.Node, name: str | w.Name, body=NOTHING, decorator_list=NOTHING, returns: Optional[w.WrappedNode | w.Node] = None, type_comment: Optional[str] = None)

Bases: stmt

args: arguments

name: str

body: Sequence[stmt]

decorator_list: Sequence[expr]

returns: Optional[expr]

type_comment: Optional[str]

class wast.nodes.AsyncFunctionDef(args: w.WrappedNode | w.Node, name: str | w.Name, body=NOTHING, decorator_list=NOTHING, returns: Optional[w.WrappedNode | w.Node] = None, type_comment: Optional[str] = None)

Bases: stmt

args: arguments

name: str

body: Sequence[stmt]

decorator_list: Sequence[expr]

returns: Optional[expr]

type_comment: Optional[str]

class wast.nodes.ClassDef(name: str | w.Name, bases=NOTHING, body=NOTHING, decorator_list=NOTHING, keywords=NOTHING)

Bases: stmt

name: str

bases: Sequence[expr]

body: Sequence[stmt]

decorator_list: Sequence[expr]

keywords: Sequence[keyword]

class wast.nodes.Return(value: Optional[w.WrappedNode | w.Node] = None)

Bases: stmt

value: Optional[expr]

class wast.nodes.Delete(targets=NOTHING)

Bases: stmt

targets: Sequence[expr]

class wast.nodes.Assign(value: w.WrappedNode | w.Node, targets=NOTHING, type_comment: Optional[str] = None)

Bases: stmt

value: expr

targets: Sequence[expr]

type_comment: Optional[str]

class wast.nodes.AugAssign(op: w.WrappedNode | w.Node, target: w.WrappedNode | w.Node, value: w.WrappedNode | w.Node)

Bases: stmt

op: operator

target: expr

value: expr

class wast.nodes.AnnAssign(annotation: w.WrappedNode | w.Node, simple: int, target: w.WrappedNode | w.Node, value: Optional[w.WrappedNode | w.Node] = None)

Bases: stmt

annotation: expr

simple: int

target: expr

value: Optional[expr]

class wast.nodes.For(iter: w.WrappedNode | w.Node, target: w.WrappedNode | w.Node, body=NOTHING, orelse=NOTHING, type_comment: Optional[str] = None)

Bases: stmt

iter: expr

target: expr

body: Sequence[stmt]

orelse: Sequence[stmt]

type_comment: Optional[str]

class wast.nodes.AsyncFor(iter: w.WrappedNode | w.Node, target: w.WrappedNode | w.Node, body=NOTHING, orelse=NOTHING, type_comment: Optional[str] = None)

Bases: stmt

iter: expr

target: expr

body: Sequence[stmt]

orelse: Sequence[stmt]

type_comment: Optional[str]

class wast.nodes.While(test: w.WrappedNode | w.Node, body=NOTHING, orelse=NOTHING)

Bases: stmt

test: expr

body: Sequence[stmt]

orelse: Sequence[stmt]

class wast.nodes.If(test: w.WrappedNode | w.Node, body=NOTHING, orelse=NOTHING)

Bases: stmt

test: expr

body: Sequence[stmt]

orelse: Sequence[stmt]

class wast.nodes.With(body=NOTHING, items=NOTHING, type_comment: Optional[str] = None)

Bases: stmt

body: Sequence[stmt]

items: Sequence[withitem]

type_comment: Optional[str]

class wast.nodes.AsyncWith(body=NOTHING, items=NOTHING, type_comment: Optional[str] = None)

Bases: stmt

body: Sequence[stmt]

items: Sequence[withitem]

type_comment: Optional[str]

class wast.nodes.Match(subject: w.WrappedNode | w.Node, cases=NOTHING)

Bases: stmt

subject: expr

cases: Sequence[match_case]

class wast.nodes.Raise(cause: Optional[w.WrappedNode | w.Node] = None, exc: Optional[w.WrappedNode | w.Node] = None)

Bases: stmt

cause: Optional[expr]

exc: Optional[expr]

class wast.nodes.Try(body=NOTHING, finalbody=NOTHING, handlers=NOTHING, orelse=NOTHING)

Bases: stmt

body: Sequence[stmt]

finalbody: Sequence[stmt]

handlers: Sequence[excepthandler]

orelse: Sequence[stmt]

class wast.nodes.Assert(test: w.WrappedNode | w.Node, msg: Optional[w.WrappedNode | w.Node] = None)

Bases: stmt

test: expr

msg: Optional[expr]

class wast.nodes.Import(names=NOTHING)

Bases: stmt

names: Sequence[alias]

class wast.nodes.ImportFrom(level: Optional[int] = None, module: Optional[str | w.Name] = None, names=NOTHING)

Bases: stmt

level: Optional[int]

module: Optional[str]

names: Sequence[alias]

class wast.nodes.Global(names=NOTHING)

Bases: stmt

names: Sequence[str]

class wast.nodes.Nonlocal(names=NOTHING)

Bases: stmt

names: Sequence[str]

class wast.nodes.Expr(value: w.WrappedNode | w.Node)

Bases: stmt

value: expr

class wast.nodes.Pass

Bases: stmt

class wast.nodes.Break

Bases: stmt

class wast.nodes.Continue

Bases: stmt

class wast.nodes.expr

Bases: Node

class wast.nodes.BoolOp(op: w.WrappedNode | w.Node, values=NOTHING)

Bases: expr

op: boolop

values: Sequence[expr]

class wast.nodes.NamedExpr(target: w.WrappedNode | w.Node, value: w.WrappedNode | w.Node)

Bases: expr

target: expr

value: expr

class wast.nodes.BinOp(left: w.WrappedNode | w.Node, op: w.WrappedNode | w.Node, right: w.WrappedNode | w.Node)

Bases: expr

left: expr

op: operator

right: expr

class wast.nodes.UnaryOp(op: w.WrappedNode | w.Node, operand: w.WrappedNode | w.Node)

Bases: expr

op: unaryop

operand: expr

class wast.nodes.Lambda(args: w.WrappedNode | w.Node, body: w.WrappedNode | w.Node)

Bases: expr

args: arguments

body: expr

class wast.nodes.IfExp(body: w.WrappedNode | w.Node, orelse: w.WrappedNode | w.Node, test: w.WrappedNode | w.Node)

Bases: expr

body: expr

orelse: expr

test: expr

class wast.nodes.Dict(keys=NOTHING, values=NOTHING)

Bases: expr

keys: Sequence[expr]

values: Sequence[expr]

class wast.nodes.Set(elts=NOTHING)

Bases: expr

elts: Sequence[expr]

class wast.nodes.ListComp(elt: w.WrappedNode | w.Node, generators=NOTHING)

Bases: expr

elt: expr

generators: Sequence[comprehension]

class wast.nodes.SetComp(elt: w.WrappedNode | w.Node, generators=NOTHING)

Bases: expr

elt: expr

generators: Sequence[comprehension]

class wast.nodes.DictComp(key: w.WrappedNode | w.Node, value: w.WrappedNode | w.Node, generators=NOTHING)

Bases: expr

key: expr

value: expr

generators: Sequence[comprehension]

class wast.nodes.GeneratorExp(elt: w.WrappedNode | w.Node, generators=NOTHING)

Bases: expr

elt: expr

generators: Sequence[comprehension]

class wast.nodes.Await(value: w.WrappedNode | w.Node)

Bases: expr

value: expr

class wast.nodes.Yield(value: Optional[w.WrappedNode | w.Node] = None)

Bases: expr

value: Optional[expr]

class wast.nodes.YieldFrom(value: w.WrappedNode | w.Node)

Bases: expr

value: expr

class wast.nodes.Compare(left: w.WrappedNode | w.Node, comparators=NOTHING, ops=NOTHING)

Bases: expr

left: expr

comparators: Sequence[expr]

ops: Sequence[cmpop]

class wast.nodes.Call(func: w.WrappedNode | w.Node, args=NOTHING, keywords=NOTHING)

Bases: expr

func: expr

args: Sequence[expr]

keywords: Sequence[keyword]

class wast.nodes.FormattedValue(value: w.WrappedNode | w.Node, conversion: Optional[int] = None, format_spec: Optional[w.WrappedNode | w.Node] = None)

Bases: expr

value: expr

conversion: Optional[int]

format_spec: Optional[expr]

class wast.nodes.JoinedStr(values=NOTHING)

Bases: expr

values: Sequence[expr]

class wast.nodes.Constant(value: Any, kind: Optional[str] = None)

Bases: expr

value: Any

kind: Optional[str]

class wast.nodes.Attribute(attr: str | w.Name, value: w.WrappedNode | w.Node)

Bases: expr

attr: str

value: expr

class wast.nodes.Subscript(slice: w.WrappedNode | w.Node, value: w.WrappedNode | w.Node)

Bases: expr

slice: expr

value: expr

class wast.nodes.Starred(value: w.WrappedNode | w.Node)

Bases: expr

value: expr

class wast.nodes.Name(id: str | w.Name)

Bases: expr

id: str

class wast.nodes.List(elts=NOTHING)

Bases: expr

elts: Sequence[expr]

class wast.nodes.Tuple(elts=NOTHING)

Bases: expr

elts: Sequence[expr]

class wast.nodes.Slice(lower: Optional[w.WrappedNode | w.Node] = None, step: Optional[w.WrappedNode | w.Node] = None, upper: Optional[w.WrappedNode | w.Node] = None)

Bases: expr

lower: Optional[expr]

step: Optional[expr]

upper: Optional[expr]

class wast.nodes.expr_context

Bases: Node

class wast.nodes.Load

Bases: expr_context

class wast.nodes.Store

Bases: expr_context

class wast.nodes.Del

Bases: expr_context

class wast.nodes.boolop

Bases: Node

class wast.nodes.And

Bases: boolop

class wast.nodes.Or

Bases: boolop

class wast.nodes.operator

Bases: Node

class wast.nodes.Add

Bases: operator

class wast.nodes.Sub

Bases: operator

class wast.nodes.Mult

Bases: operator

class wast.nodes.MatMult

Bases: operator

class wast.nodes.Div

Bases: operator

class wast.nodes.Mod

Bases: operator

class wast.nodes.Pow

Bases: operator

class wast.nodes.LShift

Bases: operator

class wast.nodes.RShift

Bases: operator

class wast.nodes.BitOr

Bases: operator

class wast.nodes.BitXor

Bases: operator

class wast.nodes.BitAnd

Bases: operator

class wast.nodes.FloorDiv

Bases: operator

class wast.nodes.unaryop

Bases: Node

class wast.nodes.Invert

Bases: unaryop

class wast.nodes.Not

Bases: unaryop

class wast.nodes.UAdd

Bases: unaryop

class wast.nodes.USub

Bases: unaryop

class wast.nodes.cmpop

Bases: Node

class wast.nodes.Eq

Bases: cmpop

class wast.nodes.NotEq

Bases: cmpop

class wast.nodes.Lt

Bases: cmpop

class wast.nodes.LtE

Bases: cmpop

class wast.nodes.Gt

Bases: cmpop

class wast.nodes.GtE

Bases: cmpop

class wast.nodes.Is

Bases: cmpop

class wast.nodes.IsNot

Bases: cmpop

class wast.nodes.In

Bases: cmpop

class wast.nodes.NotIn

Bases: cmpop

class wast.nodes.comprehension(is_async: int, iter: w.WrappedNode | w.Node, target: w.WrappedNode | w.Node, ifs=NOTHING)

Bases: Node

is_async: int

iter: expr

target: expr

ifs: Sequence[expr]

class wast.nodes.excepthandler

Bases: Node

class wast.nodes.ExceptHandler(body=NOTHING, name: Optional[str | w.Name] = None, type: Optional[w.WrappedNode | w.Node] = None)

Bases: excepthandler

body: Sequence[stmt]

name: Optional[str]

type: Optional[expr]

class wast.nodes.arguments(args=NOTHING, defaults=NOTHING, kw_defaults=NOTHING, kwarg: Optional[w.WrappedNode | w.Node] = None, kwonlyargs=NOTHING, posonlyargs=NOTHING, vararg: Optional[w.WrappedNode | w.Node] = None)

Bases: Node

args: Sequence[arg]

defaults: Sequence[expr]

kw_defaults: Sequence[expr]

kwarg: Optional[arg]

kwonlyargs: Sequence[arg]

posonlyargs: Sequence[arg]

vararg: Optional[arg]

class wast.nodes.arg(arg: str | w.Name, annotation: Optional[w.WrappedNode | w.Node] = None, type_comment: Optional[str] = None)

Bases: Node

arg: str

annotation: Optional[expr]

type_comment: Optional[str]

class wast.nodes.keyword(value: w.WrappedNode | w.Node, arg: Optional[str | w.Name] = None)

Bases: Node

value: expr

arg: Optional[str]

class wast.nodes.alias(name: str | w.Name, asname: Optional[str | w.Name] = None)

Bases: Node

name: str

asname: Optional[str]

class wast.nodes.withitem(context_expr: w.WrappedNode | w.Node, optional_vars: Optional[w.WrappedNode | w.Node] = None)

Bases: Node

context_expr: expr

optional_vars: Optional[expr]

class wast.nodes.match_case(pattern: w.WrappedNode | w.Node, body=NOTHING, guard: Optional[w.WrappedNode | w.Node] = None)

Bases: Node

pattern: pattern

body: Sequence[stmt]

guard: Optional[expr]

class wast.nodes.pattern

Bases: Node

class wast.nodes.MatchValue(value: w.WrappedNode | w.Node)

Bases: pattern

value: expr

class wast.nodes.MatchSingleton(value: Any)

Bases: pattern

value: Any

class wast.nodes.MatchSequence(patterns=NOTHING)

Bases: pattern

patterns: Sequence[pattern]

class wast.nodes.MatchMapping(keys=NOTHING, patterns=NOTHING, rest: Optional[str | w.Name] = None)

Bases: pattern

keys: Sequence[expr]

patterns: Sequence[pattern]

rest: Optional[str]

class wast.nodes.MatchClass(cls: w.WrappedNode | w.Node, kwd_attrs=NOTHING, kwd_patterns=NOTHING, patterns=NOTHING)

Bases: pattern

cls: expr

kwd_attrs: Sequence[str]

kwd_patterns: Sequence[pattern]

patterns: Sequence[pattern]

class wast.nodes.MatchStar(name: Optional[str | w.Name] = None)

Bases: pattern

name: Optional[str]

class wast.nodes.MatchAs(name: Optional[str | w.Name] = None, pattern: Optional[w.WrappedNode | w.Node] = None)

Bases: pattern

name: Optional[str]

pattern: Optional[pattern]

class wast.nodes.MatchOr(patterns=NOTHING)

Bases: pattern

patterns: Sequence[pattern]

class wast.nodes.type_ignore

Bases: Node

class wast.nodes.TypeIgnore(lineno: int, tag: str)

Bases: type_ignore

lineno: int

tag: str