E#i3SrSSKJr SSKJrJr SSKJrJr "SS\ 5r "SS \ 5r "S S \ 5r "S S \ \ S9rSrg)zNodes that make up parse trees Parsing spits out a tree of these, which you can then tell to walk itself and spit out a useful value. Or you can walk it yourself; the structural attributes are public. ) isfunction) version_infoexc_info)VisitationErrorUndefinedLabelcv\rSrSrSr/SQrSSjr\S5rSr \S5r SS jr S r S r S rSS jrSrg)NodeaA parse tree node Consider these immutable once constructed. As a side effect of a memory-saving strategy in the cache, multiple references to a single ``Node`` might be returned in a single parse tree. So, if you start messing with one, you'll see surprising parallel changes pop up elsewhere. My philosophy is that parse trees (and their nodes) should be representation-agnostic. That is, they shouldn't get all mixed up with what the final rendered form of a wiki page (or the intermediate representation of a programming language, or whatever) is going to be: you should be able to parse once and render several representations from the tree, one after another. expr full_textstartendchildrenNcTXlX lX0lX@lU=(d /UlgNr )selfr rrrrs e/home/james-whalen/.local/lib/python3.13/site-packages/ccxt/static_dependencies/parsimonious/nodes.py__init__ Node.__init__(s! "  B c.URR$r)r namers r expr_nameNode.expr_name/syy~~rc,[UR5$)zSupport looping over my children and doing tuple unpacks on me. It can be very handy to unpack nodes in arg lists; see :class:`PegVisitor` for an example. )iterrrs r__iter__ Node.__iter__4sDMM""rcHURURUR$)z"Return the text this node matched.)rrrrs rtext Node.text=s~~djj22rc 0SnSURR<UR(aSUR-OS<SUR<SXLaSOS<3/nUH'nUR U"UR US955 M) S R U5$) z{Return a unicode, pretty-printed representation of me. :arg error: The node to highlight because an error occurred there cNSRSUR555$)N c3,# UH nSU-v M g7f)z N).0lines r 0Node.prettily..indent..MsK9Jftm9Js)join splitlines)r#s rindentNode.prettily..indentLs99K9JKK Krz <-- *** We were here. ***)errorr') __class____name__rr#appendprettilyr.)rr4r0retns rr8 Node.prettilyDs L NN # #15^dnn ,R G II-2] ) B DE A JJvajjuj56 7yy~rc"UR5$)z6Return a compact, human-readable representation of me.)r8rs r__str__ Node.__str__Ws}}rcj[U[5(d[$URUR:H=(ay URUR:H=(aY UR UR :H=(a9 UR UR :H=(a URUR:H$)z>Support by-value deep comparison with other nodes for testing.) isinstancer NotImplementedr rrrrrothers r__eq__ Node.__eq__[s%&&! ! UZZ'0%//10 ekk)0EII%0 /  1rc X:X+$rr)rBs r__ne__ Node.__ne__fs   rcU(aSUR-/O/nURURR<SUR<SUR <SUR <UR(a;SSRURVs/sHo3RSS9PM sn5-OS<S 3 5 S RU5$s snf) zFReturn a bit of code (though not an expression) that will recreate me.zs = %r(z, s, z, z, children=[%s]F) top_levelr3)r') rr7r5r6r rrrr.__repr__)rrKr9cs rrM Node.__repr__is .7x$..()B NN # # II JJ HH}} YYT]]K] U 3]K LM"$ % & 'yy~LsC )rrr rrr)T)r6 __module__ __qualname____firstlineno____doc__ __slots__rpropertyrr r#r8r=rDrGrM__static_attributes__r)rrr r sY"I'#33 & 1!rr c\rSrSrSrS/rSrg) RegexNodezzNode returned from a ``Regex`` expression Grants access to the ``re.Match`` object, in case you want to access capturing groups, etc. matchr)N)r6rPrQrRrSrTrVr)rrrXrXzs  IrrXc(^\rSrSrU4SjrSrU=r$)RuleDecoratorMetact>^SmUR5VVs/sH,upE[US5(dM[U5(dM*UPM. nnnU(aJSSKJn UR [ SS:aSOSS 9 U"S RU4S jU555US '[[U]+XX#5$s snnf) Nc<URS5(aUSS$U$)z/Remove any leading "visit_" from a method name.visit_N) startswith)rs runvisit*RuleDecoratorMeta.__new__..unvisits!#x8848 Bd Br_ruler)Grammarrc.URR$r) func_codeco_firstlinenoxs r+RuleDecoratorMeta.__new__..s (B(Brc.URR$r)__code__rjrks rrmrns (A(Ar)keyr'c3x># UH/nSRT"UR5URS9v M1 g7f)z{name} = {expr})rr N)formatr6re)r*mrcs rr,,RuleDecoratorMeta.__new__..s;,#*a,22 8K893A#*s7:grammar) itemshasattrrrvrfsortrr.superr\__new__) metaclassrbases namespacekvmethodsrfrcr5s @rr{RuleDecoratorMeta.__new__s C"+!2:!21g&+5a=!2:  ( LL ,Q! 3CA  D $+ ,#*,,$-Ii &((1 J K:sB4B4B4r))r6rPrQrRr{rV __classcell__)r5s@rr\r\sKKrr\cL\rSrSrSrSrSrSrSrS Sjr S Sjr S r S r Sr g) NodeVisitora=A shell for writing things that turn parse trees into something useful Performs a depth-first traversal of an AST. Subclass this, add methods for each expr you care about, instantiate, and call ``visit(top_node_of_parse_tree)``. It'll return the useful stuff. This API is very similar to that of ``ast.NodeVisitor``. These could easily all be static methods, but that would add at least as much weirdness at the call site as the ``()`` for instantiation. And this way, we support subclasses that require state: options, for example, or a symbol table constructed from a programming language's AST. We never transform the parse tree in place, because... * There are likely multiple references to the same ``Node`` object in a parse tree, and changes to one reference would surprise you elsewhere. * It makes it impossible to report errors: you'd end up with the "error" arrow pointing someplace in a half-transformed mishmash of nodes--and that's assuming you're even transforming the tree into another tree. Heaven forbid you're making it into a string or something else. Nr)c L[USUR-UR5nU"XVs/sHo0RU5PM sn5$s snf![[ 4a e[ a7n[X@R5(ae[U5n[ XEU5eSnAff=f)aWalk a parse tree, transforming it into another representation. Recursively descend a parse tree, dispatching to the method named after the rule in the :class:`~.grammar.Grammar` that produced each node. If, for example, a rule was... :: bold = '' ...the ``visit_bold()`` method would be called. It is your responsibility to subclass :class:`NodeVisitor` and implement those methods. r`N) getattrr generic_visitvisitrr Exceptionr@unwrapped_exceptionstype)rnodemethodr:exc exc_classs rrNodeVisitor.visitsx$..8$:L:LM 8$ =1A => > =0   8#8899S I!#$7 7 8s(AA A AB#,2BB#cN[SURR5-5e)a-Default visitor method :arg node: The node we're visiting :arg visited_children: The results of visiting the children of that node, in a list I'm not sure there's an implementation of this that makes sense across all (or even most) use cases, so we leave it to subclasses to implement for now. z5No visitor method was defined for this expression: %s)NotImplementedErrorr as_rule)rrvisited_childrens rrNodeVisitor.generic_visits)""Y"&))"3"3"5#67 7rc&URXS5$)zParse some text with this Visitor's default grammar and return the result of visiting it. ``SomeVisitor().parse('some_string')`` is a shortcut for ``SomeVisitor().visit(some_grammar.parse('some_string'))``. parse_parse_or_matchrr#poss rrNodeVisitor.parse##Dw77rc&URXS5$)zParse and visit some text with this Visitor's default grammar, but don't insist on parsing all the way to the end. ``SomeVisitor().match('some_string')`` is a shortcut for ``SomeVisitor().visit(some_grammar.match('some_string'))``. rZrrs rrZNodeVisitor.matchrrcUunU$)z7Lift the sole child of ``node`` up to replace the node.r))rrr first_childs r lift_childNodeVisitor.lift_child s rcUR(d-[SRURRUS95eUR [ URU5"XS95$)zExecute a parse or match on the default grammar, followed by a visitation. Raise RuntimeError if there is no default grammar specified. zThe {cls}.{method}() shortcut won't work because {cls} was never associated with a specific grammar. Fill out its `grammar` attribute, and try again.)clsr)r)rv RuntimeErrorrsr5r6rr)rr#r method_names rrNodeVisitor._parse_or_matchs]||66TUlU$r)re)r rule_strings r decoratorrule..decoratorBs"  rr))rrs` rruler"s@ rN)rSinspectrsysrr exceptionsrrobjectr rXrr\rrr)rrrsW&7h6hVKK2BM&$5BMJ#r