XhdzdZddlmZmZddlmZddlmZddlm Z ddl m Z ddl m Z dd lmZdd lmZdd lmZmZdd lmZGd dZGddeZGddeZGddeZGddeZGddZGddeZGddeZGddZGdd eZ d!Z!Gd"d#e Z"Gd$d%eZ#y&)'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/ )Type AbstractSet)randint)deque) attrgetter) import_module)partial)AmbiguousIntermediateExpander)Discard)logger OrderedSet)Treec eZdZy) ForestNodeN__name__ __module__ __qualname__N/var/www/html/myenv/lib/python3.12/site-packages/lark/parsers/earley_forest.pyrrsrrcneZdZUdZeZeeed<dZ dZ dZ dZ dZ edZed Zd Zd Zy ) SymbolNodea 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: For dynamic lexers, the index of the start of the substring matched by this symbol (inclusive). end: For dynamic lexers, 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. Set)sstartend _childrenpaths paths_loadedpriorityis_intermediatec||_||_||_|j|_|j|_d|_td|_t|t|_ y)NF-inf) rrrrrr r!floatr" isinstancetupler#)selfrrrs r__init__zSymbolNode.__init__2sU XXZ !f  )!U3rc V|jjt||||||yN)radd PackedNode)r)lr0rulerleftrights r add_familyzSymbolNode.add_family?s# :dCudEJKrc>|jj||fyr,)r r-)r) transitivenodes radd_pathzSymbolNode.add_pathBs  D)*rc|jD]R\}}|jt||jj|jj|j }|j |j||j|jjj|jj|jj|jj||j|jjj|jj|jj|jj|Ud|_ y)NT) r next_titemtyperrrr7r3 reductionr0originr6r!)r)r5r6vns r load_pathszSymbolNode.load_pathsEsI $  Z J$$0T$Z 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  Z!rc2t|jdkDS)z'Returns True if this node is ambiguous.)lenchildrenr)s r is_ambiguouszSymbolNode.is_ambiguousOs4==!A%%rcz|js|jt|jt dS)zVReturns a list of this node's children sorted from greatest to least priority.sort_key)key)r!r>sortedrrrCs rrBzSymbolNode.childrenTs-  OO dnn*Z*@AArc,t|jSr,)iterrrCs r__iter__zSymbolNode.__iter__\sDNN##rc|jr|jd}|jd}d|jd|D}d|j|dD}dj|jj dj |dj |}n|jj }dj||j|j|jS)Nrr@c34K|]}|jywr,name.0 expansions r z&SymbolNode.__repr__..cM)y~~Mc34K|]}|jywr,rNrPs rrSz&SymbolNode.__repr__..dLinnLrU {} ::= {}* {} ({}, {}, {}, {})) r#rrRformatr<rOjoinrrr"r)r0ptrbeforeaftersymbols r__repr__zSymbolNode.__repr___s   66!9D&&)CMt~~ds7KMFLdnnST6JLE$++DKK,<,NPSPXPXY^P_`FVV[[F!((TXXt}}UUrN)rrr__doc__setrrr__annotations__ __slots__r*r3r7r>propertyrDrBrKrbrrrrrsg,!Ck  jI 4L+!&&BB$ VrrceZdZdZeZy)StableSymbolNodezAA version of SymbolNode that uses OrderedSet for output stabilityN)rrrrcrrrrrririjs G CrricbeZdZdZdZdZedZedZedZ dZ dZ d Z d Z y ) r.ay 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. )parentrr0rr1r2r"_hashc||_||_||_||_||_||_t d|_t|j|j f|_ y)Nr%) rkrrr0r1r2r&r"hashrl)r)rkrr0rr1r2s rr*zPackedNode.__init__zsP     f  499djj12 rc>|jduxr|jduSr,r1r2rCs ris_emptyzPackedNode.is_emptysyyD 7TZZ4%77rc^|j|j |jjfS)a 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. )rqr"r0orderrCs rrFzPackedNode.sort_keys#}}t}}ndiioo==rc^|j|jfDcgc]}|| c}Scc}w)z'Returns a list of this node's children.rp)r)xs rrBzPackedNode.childrens)!IItzz2DaamDDDs**c#DK|j|jywr,rprCs rrKzPackedNode.__iter__iijj ct|tsy||uxs4|j|jk(xr|j|jk(SNF)r'r.r1r2r)others r__eq__zPackedNode.__eq__s=%,u}Wejj!8!VTZZ5;;=VWrc|jSr,rlrCs r__hash__zPackedNode.__hash__ zzrct|jtr|jd}|jd}d|jd|D}d|j|dD}dj |j j dj|dj|}n|jj }dj ||j|j|jjS)Nrr@c34K|]}|jywr,rNrPs rrSz&PackedNode.__repr__..rTrUc34K|]}|jywr,rNrPs rrSz&PackedNode.__repr__..rWrUrXrYrZ) r'rr(rRr[r<rOr\rr"r0rsr]s rrbzPackedNode.__repr__s dffe $66!9D&&)CMt~~ds7KMFLdnnST6JLE$++DKK,<,NPSPXPXY^P_`FVV[[F!((T]]DIIOO\\rN)rrrrcrfr*rgrqrFrBrKr}rrbrrrr.r.nsh WI388>>EEX  ]rr.c.eZdZdZdZddZdZdZdZy) 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"rlNc~||_||_|||_n| |jnd|_t||_yNr)rrr"rnrl)r)rrr"s rr*zTokenNode.__init__s:   $DM-1-=DMM1DM%[ rcbt|tsy||uxs|j|jk(Srz)r'rrr{s rr}zTokenNode.__eq__s+%+u};u{{!:;rc|jSr,rrCs rrzTokenNode.__hash__rrc,t|jSr,)reprrrCs rrbzTokenNode.__repr__sDJJrr,) rrrrcrfr*r}rrbrrrrrs"7I!<  rrcHeZdZdZd dZdZdZdZdZdZ dZ d Z d Z y ) ForestVisitora 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. c||_yr, single_visit)r)rs rr*zForestVisitor.__init__s (rcy)zFCalled when a ``Token`` is visited. ``Token`` nodes are always leaves.Nrr)r6s rvisit_token_nodezForestVisitor.visit_token_nodes rcy)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_inz"ForestVisitor.visit_symbol_node_in rcy)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_outz#ForestVisitor.visit_symbol_node_outrrcy)zgCalled when a packed node is visited. Nodes that are returned will be scheduled to be visited. Nrrs rvisit_packed_node_inz"ForestVisitor.visit_packed_node_in rcy)zmCalled after all nodes returned from a corresponding ``visit_packed_node_in`` call have been visited.Nrrs rvisit_packed_node_outz#ForestVisitor.visit_packed_node_outrrcy)aCalled 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)r6paths ron_cyclezForestVisitor.on_cycles rct|dz }t||t|k7r |dz}t||t|k7r ||dS)zA utility function for use in ``on_cycle`` to obtain a slice of ``path`` that only contains the nodes that make up the cycle.r@N)rAid)r)r6rindexs rget_cycle_in_pathzForestVisitor.get_cycle_in_path sPD A eoD) QJEeoD)EF|rct}t}g}t|g}t|d}t|d}t|d}t|d} t|d|} t|d| } t|d} t|d} |rMtt |} t|}|%t ||vr | ||<|j |Nyy#t$r|jYkt$rYnwxYwt|tr#| |j|jt |}||vryt|tr ||n|jr | |n|||j|j|j||j!|n|j"r||vr|jn|j!||j |t|tr ||}n|jr | |}n| |}|t|t$s t'|}nt ||vr | |||j ||r) Nrrrrvisit_intermediate_node_outvisit_intermediate_node_inrr)rdrgetattrnextreversedrappend StopIterationpop TypeErrorr'rrr.r#remover-rrrJ)r)rootvisitingvisitedr input_stackvpnovpnivsnovsnivinovinivtnoccurrent next_node current_ids rvisitzForestVisitor.visitsL 5%TFm t45t34t45t34t:DAt94@d./ T: &8K01G  M $i=H,y$'""9-'! !  '9-GMM"!GJX%gz2M,,MM!  + J'""zW'<! Z( G$gz2 $W I,, $W I $W I$!)Z8 $YI ]h.y$'""9-us CC;0C;:C;N)F) rrrrcr*rrrrrrrrrrrrrs5$)      X.rrcjeZdZdZfdZdZdZdZdZdZ dZ d Z d Z d Z d Zd ZdZxZS)ForestTransformeraThe 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. cftt| t|_t |_yr,)superrr*dictdatar node_stackr) __class__s rr*zForestTransformer.__init__}s# /1F 'rc|jjdg|jd<|j|t |jddksJ|jdr|jddSy)z$Perform a transformation on an SPPF.resultr@rN)rrrrrA)r)rs r transformzForestTransformer.transformso x(  ( 4499X&'1,,, 99X 99X&q) ) rc|S)zTransform a symbol node.rr)r6rs rtransform_symbol_nodez'ForestTransformer.transform_symbol_node rc|S)zTransform an intermediate node.rrs rtransform_intermediate_nodez-ForestTransformer.transform_intermediate_noderrc|S)zTransform a packed node.rrs rtransform_packed_nodez'ForestTransformer.transform_packed_noderrc|S)zTransform a ``Token``.rrs rtransform_token_nodez&ForestTransformer.transform_token_noderrc|jjt|g|jt|<|jSr,rrrrrBrs rrz&ForestTransformer.visit_symbol_node_in4 r$x(  "T(}}rc|jjt|g|jt|<|jSr,rrs rrz&ForestTransformer.visit_packed_node_inrrc|j|}|tur,|j|jdj |yyN)rr rrr)r)r6 transformeds rrz"ForestTransformer.visit_token_nodes?//5 g % IIdoob) * 1 1+ > &rc|jj|||jt|}|tur+|j|jdj ||jt|=yr)rrrrr r)r)r6methodrs r_visit_node_out_helperz(ForestTransformer._visit_node_out_helpersc T499RX#67 g % IIdoob) * 1 1+ > IIbh rc<|j||jyr,)rrrs rrz'ForestTransformer.visit_symbol_node_out ##D$*D*DErc<|j||jyr,)rrrs rrz-ForestTransformer.visit_intermediate_node_outs ##D$*J*JKrc<|j||jyr,)rrrs rrz'ForestTransformer.visit_packed_node_outrr)rrrrcr*rrrrrrrrrrrr __classcell__rs@rrrlsL "*  ?  FLFrrc:eZdZdZfdZdZdZdZdZxZ S)ForestSumVisitoraq 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.tt| dy)NTr)rrr*rs rr*zForestSumVisitor.__init__s .D.Arc#DK|j|jywr,rprs rrz%ForestSumVisitor.visit_packed_node_inrwrxc,t|jSr,)rJrBrs rrz%ForestSumVisitor.visit_symbol_node_insDMM""rc*|jjs@|jjjr |jjjnd}|t |j ddz }|t |jddz }||_y)Nrr")rkr#r0optionsr"rr2r1)r)r6r"s rrz&ForestSumVisitor.visit_packed_node_outsp59[[5P5PUYU^U^UfUfUoUo499$$--uvGDJJ A66GDIIz155  rcFtd|jD|_y)Nc34K|]}|jywr,)r")rQchilds rrSz9ForestSumVisitor.visit_symbol_node_out..sFuENNFrU)maxrBr"rs rrz&ForestSumVisitor.visit_symbol_node_outsF FF r) rrrrcr*rrrrrrs@rrrs#B#! Grrc8eZdZdZGddZeZdZy) PackedDataz}Used in transformationss of packed nodes to distinguish the data that comes from the left child and the right child. c eZdZy)PackedData._NoDataNrrrr_NoDatars rrc|j|_|j|_|r;|j$|d|_t|dkDr |d|_yy|d|_yy)Nrr@)NO_DATAr1r2rArs rr*zPackedData.__init__s]LL \\ yy$ G t9q=!%aDJ!"!W rN)rrrrcrrr*rrrrrs  iG %rrceZdZdZeeeddffd ZfdZdZ dZ dZ dZ d Z d Zd Zd Zfd ZfdZfdZxZS)ForestToParseTreeaoUsed 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. Tctt| ||_||_||_||_||_i|_d|_ d|_ t|_ yrz) rrr* tree_class callbacks prioritizerresolve_ambiguity _use_cache_cache_on_cycle_retreat _cycle_noderd_successful_visits)r)rrrr use_cachers rr*zForestToParseTree.__init__sW /1$"&!2# !&"%%rc|jr|jj|tt||i|_yr,)rrrrr)r)rrs rrzForestToParseTree.visits7       " "4 ( ,T2 rcLtjd|||_d|_y)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 debugrrrs rrzForestToParseTree.on_cycles* @AE G !%rc|jrMt|t|jk(st||jvrd|_d|_ytSyrz)rrrrr rs r _check_cyclezForestToParseTree._check_cyclesM  ! !$x2d..//2d8t?V?V3V#' ).& "rcg}|D]>}t|dr|jdk(r||jz }.|j|@|S)Nr_ambig)hasattrrrBr)r)rB new_childrenrs r_collapse_ambigz!ForestToParseTree._collapse_ambig#sO  +Euf%%***@. ##E*  + rc@|j|j|Sr,)rr0rs r_call_rule_funcz!ForestToParseTree._call_rule_func,s)t~~dii(..rc\t|dkDr|jd|S|r|dStS)Nr@rrrArr rs r_call_ambig_funcz"ForestToParseTree._call_ambig_func2s1 t9q=??8T2 2 7Nrct||jvrtS|j|}|tur|S|jj t||j |}|j ||Sr,)rrr rrrr)r)r6rrs rrz'ForestToParseTree.transform_symbol_node<sp d8422 2N   d # <H &&r$x0##D)$$T400rcLt||jvrtS|j|}|tur|S|jj t|t |dkDr1|Dcgc]}|j d|}}|j d|S|dScc}w)Nr@_inter_iambigr)rrr rrrAr)r)r6rrcrBs rrz-ForestToParseTree.transform_intermediate_nodeFs d8422 2N   d # <H &&r$x0 t9q=>BC!4CHC??9h7 7AwDs/B!cL|j|}|tur|S|jr't|j|j vrtS|j r/t||jvr|jt|Sg}t|dksJt||}|jtjur[|jjr*t|jtr||jz }n|j|j|j tjur|j|j |jjr|n|j#||}|j r||jt|<|S)Nr )rr rrrkrrrrArr1rr#r'listrr2r)r)r6rrrBrs rrz'ForestToParseTree.transform_packed_nodeRs8   d # <H  ! !bo9P9P&PN ??r$x4;;6;;r$x( (4yA~~$% 99J.. .yy((Z 4-HDII% * ::Z// / OODJJ '"&++"="=h4CWCWX\^fCg ??$/DKK4 !rc\tt| ||jry|jSr,)rrrrrBr)r6rs rrz&ForestToParseTree.visit_symbol_node_inis) ;DA  ! ! }}rcd|_tt||}|jr!t |j |jvr&|jrt ||jvr|Syyrz) rrrrrrrkrrr)r)r6to_visitrs rrz&ForestToParseTree.visit_packed_node_inosb!&*DFtL%%DKK@W@W)W??bhdkk&A'B*Xrctt| ||js/|jj t |jyyr,)rrrrrr-rrkr"s rrz'ForestToParseTree.visit_packed_node_outvs= (>?EErc|jjxsB|jjjxs |jjj }t |||j}||jk(s t|drt|j|}|js"tt|j}||}||SNr') r0aliasrtemplate_sourcer<rOrr.rr rr r)r)r6rrO user_funcwrappers rrz%TreeForestTransformer._call_rule_funcsyy\$))"3"3"C"C\tyyGWGWG\G\D$(8(89 (( (GI?R,S 0 0$7I%%;T__MG *Irc|jj}t|||j}||jk(s t |dst |j|}||Sr5)rrOrr0rr )r)r6rrOr8s rrz&TreeForestTransformer._call_ambig_funcsWvv{{D$(>(>? .. .giI\6] 6 6=Ir)rrrrcrrr*r.r0r2rrrrrs@rr*r*s? D#'4D4FZ^jos+ Frr*cLeZdZdZd fd ZfdZdZdZdZdZ dZ xZ S) ForestToPyDotVisitora 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. ctt| dtd|_|jj d||_y)NTrpydotdigraph) graph_typerankdir)rr<r*rr>Dotgraph)r)rArs rr*zForestToPyDotVisitor.__init__s: "D22E"7+ ZZ^^y'^J rctt| | |jj |y#t $r }t jd|Yd}~yd}~wwxYw)NzCould not write png: )rr<rrC write_pngFileNotFoundErrorr error)r)rfilenameers rrzForestToPyDotVisitor.visitsL "D/5 5 JJ  *  5 LL0! 4 4 5s2 AAAc"tt|}dj|jj dd}d}d}d}|j j ||dj|||}|jj|y) Nz"{}""z\"退z"filled,rounded"diamond#{:06x}style fillcolorshapelabel) strrr[valuereplacer>NoderCadd_noder)r6 graph_node_idgraph_node_labelgraph_node_colorgraph_node_stylegraph_node_shape graph_nodes rrz%ForestToPyDotVisitor.visit_token_nodesBtH #??4::+=+=c5+IJ#/$ZZ__]:JV_VfVfgwVxAQYi_j  J'rc#"Ktt|}t|}d}d}d}|jj ||dj |||}|j j||j|jyw)NrLfilledrMrNrO) rTrrr>rWr[rCrXr1r2rYs rrz)ForestToPyDotVisitor.visit_packed_node_insBtH :##$ZZ__]:JV_VfVfgwVxAQYi_j  J'iijjsB Bc tt|}|jj|d}|j|j fD]}|ttt |tr |jn|}|jj|d}|jj|jj||ttdd}d}|jj||d}d}|jj||jj|jj|||y)Nrl@*_kzcPl ~l!]cinvisNone)rPrS)rP)rTrrCget_noder1r2r'rradd_edger>EdgerrWrX) r)r6rZr_rchild_graph_node_idchild_graph_nodechild_graph_node_stylechild_edge_styles rrz*ForestToPyDotVisitor.visit_packed_node_outs!BtH ZZ((7: ii, kE &)"JuirWr[rCrXrJrBrYs rrz)ForestToPyDotVisitor.visit_symbol_node_insBtH :#'   ( * ZZ__]:JV_VfVfgwVxAQYi_j  J'DMM""rcXtt|}|jj|d}|jD]i}tt|}|jj|d}|jj |j j||kyr)rTrrCrerBrfr>rg)r)r6rZr_rrhris rrz*ForestToPyDotVisitor.visit_symbol_node_outsBtH ZZ((7: ]] OE"%bi. #zz223FGJ  JJ    r{s%#>&  OVOVbz>]>]@  <^.^.@NF NFb!G}!GF%%*D9)D9L R-RhMO=MOr