zfSrSSKJr SSKJr SSKJr SSKJr SSK J r SSK J r SS K Jr SS KJr SS KJr "S S 5r"SS\5r"SS\5r"SS\5r"SS5r"SS\5r"SS\5r"SS5r"SS\5rSr"SS \5r"S!S"\5rg#)$a8"This module implements an SPPF implementation This is used as the primary output mechanism for the Earley parser in order to store complex ambiguities. Full reference and more details is here: https://web.archive.org/web/20190616123959/http://www.bramvandersanden.com/post/2014/06/shared-packed-parse-forest/ )randint)deque) attrgetter) import_module)partial)AmbiguousIntermediateExpander)Discard)logger)Treec\rSrSrSrg) ForestNodeN__name__ __module__ __qualname____firstlineno____static_attributes__r-lib/third_party/lark/parsers/earley_forest.pyrrsrrcl\rSrSrSrSrSrSrSrSr \ S5r \ S 5r S r S rS rS rSrg) SymbolNodeax A Symbol Node represents a symbol (or Intermediate LR0). Symbol nodes are keyed by the symbol (s). For intermediate nodes s will be an LR0, stored as a tuple of (rule, ptr). For completed symbol nodes, s will be a string representing the non-terminal origin (i.e. the left hand side of the rule). The children of a Symbol or Intermediate Node will always be Packed Nodes; with each Packed Node child representing a single derivation of a production. Hence a Symbol Node with a single child is unambiguous. Parameters: s: A Symbol, or a tuple of (rule, ptr) for an intermediate node. start: The index of the start of the substring matched by this symbol (inclusive). end: The index of the end of the substring matched by this symbol (exclusive). Properties: is_intermediate: True if this node is an intermediate node. priority: The priority of the node's symbol. ) sstartend _childrenpaths paths_loadedpriorityis_intermediate_hashcXlX lX0l[5Ul[5UlSUl[S5Ul[U[5Ul [URURUR45Ul g)NF-inf)rrrsetrr r!floatr" isinstancetupler#hashr$)selfrrrs r__init__SymbolNode.__init__0sf U !f  )!U34664::txx89 rc PURR[XX#XE55 gN)radd PackedNode)r,lr0rulerleftrights r add_familySymbolNode.add_family>s :ddJKrc<URRX45 gr0)r r1)r, transitivenodes radd_pathSymbolNode.add_pathAs  )*rcURGHNupURb[URRURRUR 5nUR URU5 URURRRURRURRURRU5 MURURRRURRURRURRU5 GMQ SUl g)NT) r next_titemrrrrr<r7 reductionr4originr;r!)r,r:r;vns r load_pathsSymbolNode.load_pathsDs: $ J$$0 5 5 7 79N9N9T9TVZV^V^_ J1148 4 4 9 9 @ @*BVBVB[B[]g]q]q]w]wzDzNzNzSzSUWX 4 4 9 9 @ @*BVBVB[B[]g]q]q]w]wzDzNzNzSzSUYZ !+!rc2[UR5S:$)z'Returns True if this node is ambiguous.)lenchildrenr,s r is_ambiguousSymbolNode.is_ambiguousNs4==!A%%rc~UR(dUR5 [UR[ S5S9$)zNReturns a list of this node's children sorted from greatest to least priority.sort_key)key)r!rCsortedrrrIs rrHSymbolNode.childrenSs-  OO dnn*Z*@AArc,[UR5$r0)iterrrIs r__iter__SymbolNode.__iter__[sDNN##rcV[U[5(dgXL=(d [UR5[UR5:H=(aX URUR:H=(a8 URUR:H=(a UR UR L$NF)r)rtyperrrr,others r__eq__SymbolNode.__eq__^s%,,}Ndffegg!>"M466UWWCT"MY]YcYcglgrgrYr"Mw{wwDIDMDMxM NrcUR$r0r$rIs r__hash__SymbolNode.__hash__c zzrcUR(aURSnURSnSURSU5nSURUS5nSRURR SR U5SR U55nOURR nSRXPRURUR5$)NrrFc38# UHoRv M g7fr0name.0 expansions r &SymbolNode.__repr__..jM7K)~~7Kc38# UHoRv M g7fr0rcres rrhrikL6Jnn6Jrk {} ::= {}* {} ({}, {}, {}, {})) r#rrgformatrArdjoinrrr"r,r4ptrbeforeaftersymbols r__repr__SymbolNode.__repr__fs   66!9D&&)CMt~~ds7KMFLdnnST6JLE$++DKK,<,NPSPXPXY^P_`FVV[[F!((TXXt}}UUr) rr$rr#r r!r"rrN)rrrr__doc__ __slots__r-r7r<rCpropertyrJrHrSrZr^rxrrrrrrsd,tI :L+!&&BB$N  Vrrcj\rSrSrSrSrSr\S5r\S5r \S5r Sr S r S r S rS rg )r2qaY A Packed Node represents a single derivation in a symbol node. Parameters: rule: The rule associated with this node. parent: The parent of this node. left: The left child of this node. ``None`` if one does not exist. right: The right child of this node. ``None`` if one does not exist. priority: The priority of this node. )parentrr4rr5r6r"r$cXlX lX@lX0lXPlX`l[ S5Ul[URUR 45Ul g)Nr&) rrrr4r5r6r(r"r+r$)r,rrr4rr5r6s rr-PackedNode.__init__}sD     f  499djj12 rcHURSL=(a URSL$r0r5r6rIs ris_emptyPackedNode.is_emptysyyD 7TZZ4%77rc^URUR*URR4$)z Used to sort PackedNode children of SymbolNodes. A SymbolNode has multiple PackedNodes if it matched ambiguously. Hence, we use the sort order to identify the order in which ambiguous children should be considered. )rr"r4orderrIs rrMPackedNode.sort_keys#}}t}}ndiioo==rcfURUR4Vs/sH ocMUPM sn$s snf)z'Returns a list of this node's children.r)r,xs rrHPackedNode.childrens+!IItzz2D2a2DDDs..c#D# URv URv g7fr0rrIs rrSPackedNode.__iter__iijj c[U[5(dgXL=(d9 URUR:H=(a URUR:H$rV)r)r2r5r6rXs rrZPackedNode.__eq__s>%,,}Wejj!8!VTZZ5;;=VWrcUR$r0r]rIs rr^PackedNode.__hash__r`rc[UR[5(aURSnURSnSURSU5nSURUS5nSR UR R SRU5SRU55nOURR nSR XPRURURR5$)NrrFc38# UHoRv M g7fr0rcres rrh&PackedNode.__repr__..rjrkc38# UHoRv M g7fr0rcres rrhrrmrkrnrorp) r)rr*rgrqrArdrrrr"r4rrss rrxPackedNode.__repr__s dffe $ $66!9D&&)CMt~~ds7KMFLdnnST6JLE$++DKK,<,NPSPXPXY^P_`FVV[[F!((T]]DIIOO\\r)r$r5rr"r6r4rrN)rrrrrzr{r-r|rrMrHrSrZr^rxrrrrr2r2qsh WI388>>EEX  ]rr2c8\rSrSrSrSrS SjrSrSrSr S r g) TokenNodez A Token Node represents a matched terminal and is always a leaf node. Parameters: token: The Token associated with this node. term: The TerminalDef matched by the token. priority: The priority of this node. )tokentermr"r$Nc|XlX lUbX0lOUb UROSUl[U5UlgNr)rrr"r+r$)r,rrr"s rr-TokenNode.__init__s4   $M-1-=DMM1DM%[ rct[U[5(dgXL=(d URUR:H$rV)r)rrrXs rrZTokenNode.__eq__s,%++};u{{!:;rcUR$r0r]rIs rr^TokenNode.__hash__r`rc,[UR5$r0)reprrrIs rrxTokenNode.__repr__sDJJr)r$r"rrr0) rrrrrzr{r-rZr^rxrrrrrrs"7I!<  rrcR\rSrSrSrSSjrSrSrSrSr Sr S r S r S r S rg ) ForestVisitoras An abstract base class for building forest visitors. This class performs a controllable depth-first walk of an SPPF. The visitor will not enter cycles and will backtrack if one is encountered. Subclasses are notified of cycles through the ``on_cycle`` method. Behavior for visit events is defined by overriding the ``visit*node*`` functions. The walk is controlled by the return values of the ``visit*node_in`` methods. Returning a node(s) will schedule them to be visited. The visitor will begin to backtrack if no nodes are returned. Parameters: single_visit: If ``True``, non-Token nodes will only be visited once. cXlgr0 single_visit)r,rs rr-ForestVisitor.__init__s(rcg)zFCalled when a ``Token`` is visited. ``Token`` nodes are always leaves.Nrr,r;s rvisit_token_nodeForestVisitor.visit_token_nodes rcg)zCalled when a symbol node is visited. Nodes that are returned will be scheduled to be visited. If ``visit_intermediate_node_in`` is not implemented, this function will be called for intermediate nodes as well.Nrrs rvisit_symbol_node_in"ForestVisitor.visit_symbol_node_in rcg)zCalled after all nodes returned from a corresponding ``visit_symbol_node_in`` call have been visited. If ``visit_intermediate_node_out`` is not implemented, this function will be called for intermediate nodes as well.Nrrs rvisit_symbol_node_out#ForestVisitor.visit_symbol_node_outrrcg)z_Called when a packed node is visited. Nodes that are returned will be scheduled to be visited. Nrrs rvisit_packed_node_in"ForestVisitor.visit_packed_node_in rcg)zeCalled after all nodes returned from a corresponding ``visit_packed_node_in`` call have been visited.Nrrs rvisit_packed_node_out#ForestVisitor.visit_packed_node_outrrcg)a[Called when a cycle is encountered. Parameters: node: The node that causes a cycle. path: The list of nodes being visited: nodes that have been entered but not exited. The first element is the root in a forest visit, and the last element is the node visited most recently. ``path`` should be treated as read-only. Nrr,r;paths ron_cycleForestVisitor.on_cycles rc[U5S- n[X#5[U5:wa!US-n[X#5[U5:waM!X#S$)z}A utility function for use in ``on_cycle`` to obtain a slice of ``path`` that only contains the nodes that make up the cycle.rFN)rGid)r,r;rindexs rget_cycle_in_pathForestVisitor.get_cycle_in_path sJD A oD) QJEoD)F|rc|[5n[5n/n[U/5n[US5n[US5n[US5n[US5n [USU5n [USU 5n [US5n [US5n U(aQ[[ U55n[U5nUcM,[ U5U;a U "X5 MEUR U5 MXg![a UR5 Mv[a Of=f[U[5(a$U "UR5 UR5 M[ U5nUU;a[U[5(a U"U5 O"UR(a U "U5 OU"U5 UR5 UR5 URU5 UR!U5 OUR"(aUU;aUR5 OUR!U5 UR U5 [U[5(a U"U5nO"UR(a U "U5nOU "U5nUcGM[U[$5(d ['U5nO[ U5U;a U "X5 GMUR U5 U(aGM1g) Nrrrrvisit_intermediate_node_outvisit_intermediate_node_inrr)r'rgetattrnextreversedrappend StopIterationpop TypeErrorr)rrr2r#remover1rrrR)r,rootvisitingvisitedr input_stackvpnovpnivsnovsnivinovinivtnoccurrent next_node current_ids rvisitForestVisitor.visitsT 5%TFm t45t34t45t34t:DAt94@d./ T: &8K01G  M $i=H,y'""9-'! !  '9--GMM"!GJX%gz22M,,MM!  + J'""zW'<! Z( G$gz22 $W I,, $W I $W I$!)Z88 $YI ]h.y'""9-uks! CD; DDrN)F)rrrrrzr-rrrrrrrrrrrrrrs5$)      X.rrct^\rSrSrSrU4SjrSrSrSrSr Sr S r S r S r S rS rSrSrSrU=r$)ForestTransformerioaThe base class for a bottom-up forest transformation. Most users will want to use ``TreeForestTransformer`` instead as it has a friendlier interface and covers most use cases. Transformations are applied via inheritance and overriding of the ``transform*node`` methods. ``transform_token_node`` receives a ``Token`` as an argument. All other methods receive the node that is being transformed and a list of the results of the transformations of that node's children. The return value of these methods are the resulting transformations. If ``Discard`` is raised in a node's transformation, no data from that node will be passed to its parent's transformation. cf>[[U] 5 [5Ul[ 5Ulgr0)superrr-dictdatar node_stackr, __class__s rr-ForestTransformer.__init__s# /1F 'rcURRS5 /URS'URU5 [ URS5S::deURS(aURSS$g)z$Perform a transformation on an SPPF.resultrFrN)rrrrrG)r,rs r transformForestTransformer.transformso x(  ( 4499X&'1,,, 99X 99X&q) ) rcU$)zTransform a symbol node.rr,r;rs rtransform_symbol_node'ForestTransformer.transform_symbol_node rcU$)zTransform an intermediate node.rrs rtransform_intermediate_node-ForestTransformer.transform_intermediate_noderrcU$)zTransform a packed node.rrs rtransform_packed_node'ForestTransformer.transform_packed_noderrcU$)zTransform a ``Token``.rrs rtransform_token_node&ForestTransformer.transform_token_noderrcURR[U55 /UR[U5'UR$r0rrrrrHrs rr&ForestTransformer.visit_symbol_node_in4 r$x(  "T(}}rcURR[U55 /UR[U5'UR$r0rrs rr&ForestTransformer.visit_packed_node_inrrcURU5nU[La,URURSR U5 ggN)rr rrr)r,r; transformeds rr"ForestTransformer.visit_token_nodes?//5 g % IIdoob) * 1 1+ > &rcURR5 U"XR[U55nU[La+URURSR U5 UR[U5 gr )rrrrr r)r,r;methodr s r_visit_node_out_helper(ForestTransformer._visit_node_out_helpersa T99RX#67 g % IIdoob) * 1 1+ > IIbh rc:URXR5 gr0)rrrs rr'ForestTransformer.visit_symbol_node_out ##D*D*DErc:URXR5 gr0)rrrs rr-ForestTransformer.visit_intermediate_node_outs ##D*J*JKrc:URXR5 gr0)rrrs rr'ForestTransformer.visit_packed_node_outrr)rr)rrrrrzr-rrrrrrrrrrrrr __classcell__rs@rrrosR "*  ?  FLFFrrcD^\rSrSrSrU4SjrSrSrSrSr Sr U=r $) ForestSumVisitoriaA A visitor for prioritizing ambiguous parts of the Forest. This visitor is used when support for explicit priorities on rules is requested (whether normal, or invert). It walks the forest (or subsets thereof) and cascades properties upwards from the leaves. It would be ideal to do this during parsing, however this would require processing each Earley item multiple times. That's a big performance drawback; so running a forest walk is the lesser of two evils: there can be significantly more Earley items created during parsing than there are SPPF nodes in the final tree. c(>[[U] SS9 g)NTr)rrr-rs rr-ForestSumVisitor.__init__s .D.Arc#D# URv URv g7fr0rrs rr%ForestSumVisitor.visit_packed_node_inrrc,[UR5$r0)rRrHrs rr%ForestSumVisitor.visit_symbol_node_insDMM""rc<URR(dEURRR(a URRROSnU[ UR SS5- nU[ URSS5- nX!lg)Nrr")rr#r4optionsr"rr6r5)r,r;r"s rr&ForestSumVisitor.visit_packed_node_outsn59[[5P5PUYU^U^UfUfUoUo499$$--uvGDJJ A66GDIIz155 rcF[SUR55Ulg)Nc38# UHoRv M g7fr0)r")rfchilds rrh9ForestSumVisitor.visit_symbol_node_out..sF uNN rk)maxrHr"rs rr&ForestSumVisitor.visit_symbol_node_outsF FF rr) rrrrrzr-rrrrrrrs@rrrs)B#! GGrrc@\rSrSrSr"SS5r\"5rSrSrg) PackedDataizuUsed in transformationss of packed nodes to distinguish the data that comes from the left child and the right child. c\rSrSrSrg)PackedData._NoDatairNrrrr_NoDatar/s rr0cURUlURUlU(a=URb%USUl[U5S:a USUlggUSUlgg)NrrF)NO_DATAr5r6rGrs rr-PackedData.__init__s]LL \\ yy$ G t9q=!%aDJ!"!W rrN) rrrrrzr0r2r-rrrrr-r-s  iG %rr-c^\rSrSrSr\\"5\"5SS4U4SjjrU4Sjr Sr Sr Sr S r S rS rS rS rU4SjrU4SjrU4SjrSrU=r$)ForestToParseTreeiaKUsed by the earley parser when ambiguity equals 'resolve' or 'explicit'. Transforms an SPPF into an (ambiguous) parse tree. Parameters: tree_class: The tree class to use for construction callbacks: A dictionary of rules to functions that output a tree prioritizer: A ``ForestVisitor`` that manipulates the priorities of ForestNodes resolve_ambiguity: If True, ambiguities will be resolved based on priorities. Otherwise, `_ambig` nodes will be in the resulting tree. use_cache: If True, the results of packed node transformations will be cached. Tc>[[U] 5 XlX lX0lX@lXPl0UlSUl SUl [5Ul grV) rr5r- tree_class callbacks prioritizerresolve_ambiguity _use_cache_cache_on_cycle_retreat _cycle_noder'_successful_visits)r,r7r8r9r: use_cachers rr-ForestToParseTree.__init__sM /1$"&!2# !&"%%rc>UR(aURRU5 [[U]U5 0Ulgr0)r9rrr5r<)r,rrs rrForestToParseTree.visits7       " "4 ( ,T2 rcL[R"SU5 XlSUlg)NzCycle encountered in the SPPF at node: %s. As infinite ambiguities cannot be represented in a tree, this family of derivations will be discarded.T)r debugr>r=rs rrForestToParseTree.on_cycles( @AE G !%rcUR(aP[U5[UR5:Xd[U5UR;aSUlSUlg[$grV)r=rr>r?r rs r _check_cycleForestToParseTree._check_cyclesM  ! !$x2d..//2d8t?V?V3V#' ).& "rc/nUHEn[US5(a URS:XaX#R- nM4URU5 MG U$)Nr_ambig)hasattrrrHr)r,rH new_childrenr(s r_collapse_ambig!ForestToParseTree._collapse_ambig&sK Euf%%%***@. ##E*  rc@URUR"U5$r0)r8r4rs r_call_rule_func!ForestToParseTree._call_rule_func/s~~dii(..rch[U5S:aURSU5$U(aUS$[$)NrFrKrrGr7r rs r_call_ambig_func"ForestToParseTree._call_ambig_func5s1 t9q=??8T2 2 7Nrc[U5UR;a[$URU5nU[LaU$URR [U55 UR U5nUR X5$r0)rr?r rHrrNrU)r,r;rrs rr'ForestToParseTree.transform_symbol_node?sn d8422 2N   d # <H &&r$x0##D)$$T00rcX[U5UR;a[$URU5nU[LaU$URR [U55 [ U5S:a3UVs/sHo@R SU5PM nnUR SU5$US$s snf)NrF_inter_iambigr)rr?r rHrrGr7)r,r;rrXcrHs rr-ForestToParseTree.transform_intermediate_nodeIs d8422 2N   d # <H &&r$x0 t9q=>BCd!4dHC??9h7 7AwDs3B'cURU5nU[LaU$UR(a)[UR5UR ;a[$UR (a1[U5UR;aUR[U5$/n[U5S::de[X5nUR[RLadURR(a.[UR[5(aXBR- nOURUR5 UR [RLaURUR 5 URR(a%URR#[U5U5$URR#[U5UR%X55$)Nr)rHr r:rrr?r;r<rGr-r5r2r#r)listrr6 setdefaultrQ)r,r;rrXrHs rr'ForestToParseTree.transform_packed_nodeUsD   d # <H  ! !bo9P9P&PN ??r$x4;;6;;r$x( (4yA~~$% 99J.. .yy((Z 4-H-HII% * ::Z// / OODJJ ' ;; & &;;))"T(H= ={{%%bh0D0DT0TUUrcf>[[U] U5 UR(agUR$r0)rr5rr=rHr,r;rs rr&ForestToParseTree.visit_symbol_node_inks) ;DA  ! ! }}rc>SUl[[U]U5nUR(a#[ UR 5UR;a-UR(a[ U5UR;aU$ggrV) r=rr5rr:rrr?r;r<)r,r;to_visitrs rr&ForestToParseTree.visit_packed_node_inqsb!&*DFtL%%DKK@W@W)W??bhdkk&A'B*Xrc>[[U] U5 UR(d/URR [ UR55 ggr0)rr5rr=r?r1rrrds rr'ForestToParseTree.visit_packed_node_outxs= r=r?r;r8r9r:r7)rrrrrzr rrr-rrrHrNrQrUrrrrrrrrrs@rr5r5sh #'$&FVFXlp}A ( &/ 1 V,  99rr5cSUlU$)zDecorator for methods of subclasses of ``TreeForestTransformer``. Denotes that the method should receive a list of transformed derivations.T)handles_ambiguity)funcs rrlrl}s"D Krcf^\rSrSrSr\\"5SS4U4SjjrSrSr Sr S r S r S r S rU=r$) TreeForestTransformeriaA ``ForestTransformer`` with a tree ``Transformer``-like interface. By default, it will construct a tree. Methods provided via inheritance are called based on the rule/symbol names of nodes in the forest. Methods that act on rules will receive a list of the results of the transformations of the rule's children. By default, trees and tokens. Methods that act on tokens will receive a token. Alternatively, methods that act on rules may be annotated with ``handles_ambiguity``. In this case, the function will receive a list of all the transformations of all the derivations of the rule. By default, a list of trees where each tree.data is equal to the rule name or one of its aliases. Non-tree transformations are made possible by override of ``__default__``, ``__default_token__``, and ``__default_ambig__``. Note: Tree shaping features such as inlined rules and token filtering are not built into the transformation. Positions are also not propagated. Parameters: tree_class: The tree class to use for construction prioritizer: A ``ForestVisitor`` that manipulates the priorities of nodes in the SPPF. resolve_ambiguity: If True, ambiguities will be resolved based on priorities. use_cache (bool): If True, caches the results of some transformations, potentially improving performance when ``resolve_ambiguity==False``. Only use if you know what you are doing: i.e. All transformation functions are pure and referentially transparent. TFcB>[[U] U[5X#U5 gr0)rror-r)r,r7r9r:r@rs rr-TreeForestTransformer.__init__s #T3J hqrrc$URX5$)z[Default operation on tree (for override). Returns a tree with name with data as children. )r7r,rdrs r __default__!TreeForestTransformer.__default__s t**rch[U5S:aURSU5$U(aUS$[$)z{Default operation on ambiguous rule (for override). Wraps data in an '_ambig_' node if it contains more than one element. rFrKrrTrss r__default_ambig__'TreeForestTransformer.__default_ambig__s1 t9q=??8T2 2 7NrcU$)zBDefault operation on ``Token`` (for override). Returns ``node``. rrs r__default_token__'TreeForestTransformer.__default_token__s  rcN[XRUR5"U5$r0)rrWrzrs rr*TreeForestTransformer.transform_token_nodestYY(>(>?EErcURR=(dG URRR=(d URRR n[ XUR5nX@R:Xd[US5(a[URU5nUR(d"[[UR5nU"U5nU"U5$Nrl) r4aliasr$template_sourcerArdrrtrLrr:r r7)r,r;rrd user_funcwrappers rrQ%TreeForestTransformer._call_rule_funcsyy\$))"3"3"C"C\tyyGWGWG\G\D(8(89 (( (GI?R,S,S 0 0$7I%%;T__MG *IrcURRn[XUR5nX@R:Xd[ US5(d[ URU5nU"U5$r)rrdrrwrLr)r,r;rrdrs rrU&TreeForestTransformer._call_ambig_funcsVvv{{D(>(>? .. .giI\6]6] 6 6=Irr)rrrrrzr rr-rtrwrzrrQrUrrrs@rrorosD D#'4D4FZ^jos+ FrrocZ^\rSrSrSrS U4SjjrU4SjrSrSrSr Sr S r S r U=r $) ForestToPyDotVisitoriz A Forest visitor which writes the SPPF to a PNG. The SPPF can get really large, really quickly because of the amount of meta-data it stores, so this is probably only useful for trivial trees and learning how the SPPF is structured. c>[[U] SS9 [S5UlURR SUS9Ulg)NTrpydotdigraph) graph_typerankdir)rrr-rrDotgraph)r,rrs rr-ForestToPyDotVisitor.__init__s: "D22E"7+ ZZ^^y'^J rc>[[U] U5 URR U5 g![ a!n[ R"SU5 SnAgSnAff=f)NzCould not write png: )rrrr write_pngFileNotFoundErrorr error)r,rfilenameers rrForestToPyDotVisitor.visitsL "D/5 5 JJ  *  5 LL0! 4 4 5s2 AAAc[[U55nSRURR SS55nSnSnSnUR R X%SRU5XcS9nURRU5 g) Nz"{}""z\"退z"filled,rounded"diamond#{:06x}style fillcolorshapelabel) strrrqvaluereplacerNoderadd_noder,r; graph_node_idgraph_node_labelgraph_node_colorgraph_node_stylegraph_node_shape graph_nodes rr%ForestToPyDotVisitor.visit_token_nodesBtH #??4::+=+=c5+IJ#/$ZZ__]V_VfVfgwVxAQ_j  J'rc## [[U55n[U5nSnSnSnURR X%SR U5XcS9nUR RU5 URv URv g7f)Nrfilledrrr) rrrrrrqrrr5r6rs rr)ForestToPyDotVisitor.visit_packed_node_insBtH :##$ZZ__]V_VfVfgwVxAQ_j  J'iijjsBB c [[U55nURRU5SnURUR 4GHnUb[[[ U[5(a UROU55nURRU5SnURRURRX655 M[[SS55nSnURRXWSS9nSnURRU5 URRURRX6US95 GM g)Nrl@*_kzcPl ~l!]cinvisNone)rr)r)rrrget_noder5r6r)rradd_edgerEdgerrr) r,r;rrr(child_graph_node_idchild_graph_nodechild_graph_node_stylechild_edge_styles rr*ForestToPyDotVisitor.visit_packed_node_outsBtH ZZ((7: ii,E &)"Juirs#>  WVWVr>]>]@  <^.^.@NF NFb!G}!GF%%*C9)C9J R-RhMO=MOr