
    h;                         S r SSKJrJrJrJrJr  SSKJr  SSK	J
r
  SSKJr  SSKJrJr  SSKJrJrJr  S	S
KJr  SSKJr  S	SKJr  S	SKJrJrJrJrJr  \(       a  SSK J!r!J"r"   " S S5      r#g)a  This module implements an Earley parser.

The core Earley algorithm used here is based on Elizabeth Scott's implementation, here:
    https://www.sciencedirect.com/science/article/pii/S1571066108001497

That is probably the best reference for understanding the algorithm here.

The Earley parser outputs an SPPF-tree as per that document. The SPPF tree format
is explained here: https://lark-parser.readthedocs.io/en/latest/_static/sppf/sppf.html
    )TYPE_CHECKINGCallableOptionalListAny)deque   )Token)Tree)UnexpectedEOFUnexpectedToken)logger
OrderedSet
dedup_list   )GrammarAnalyzer)NonTerminal)Item)ForestSumVisitor
SymbolNodeStableSymbolNode	TokenNodeForestToParseTree)	LexerConf
ParserConfc                       \ rS rSr% S\S'   S\S'   \\S'   SS\S4SSSSS	\S
\S\S\\\	\
/\4      S\4S jjrS rSS jrS rSrg)Parser   r   
lexer_confr   parser_confdebugTFterm_matcherresolve_ambiguity
tree_classordered_setsc                    [        U5      nXl        X l        X@l        XPl        X`l        U(       a  [        O[        U l        U(       a  [        O[        U l
        UR                  U l        UR                  U l        UR                  U l        0 U l        UR                   V	V
s1 s H*  oR                     H  oR"                  (       d  M  U
iM     M,     sn
n	U l        UR                   V	V
s1 s H*  oR                     H  oR"                  (       a  M  U
iM     M,     sn
n	U l        S U l        UR                   H  nUR*                  U R                  ;  aL  UR-                  UR*                  5       Vs/ s H  oR.                  PM     snU R                  UR*                  '   U R(                  b  Mx  UR0                  R2                  c  M  [4        U l        M     U R                  R6                  S:w  aH  U R(                  c;  U R                  R8                   H!  nUR2                  (       d  M  [4        U l          O   X0l        g s  sn
n	f s  sn
n	f s  snf )Nbasic)r   r   r    r#   r!   r   r   setSetr   r   FIRSTNULLABLE	callbackspredictionsrules	expansionis_term	TERMINALSNON_TERMINALSforest_sum_visitororiginexpand_ruleruleoptionspriorityr   
lexer_type	terminalsr"   )selfr   r    r"   r#   r!   r$   r%   analysisrsymr6   xterms                 fC:\Users\julio\OneDrive\Documentos\Trabajo\Ideas Frescas\venv\Lib\site-packages\lark/parsers/earley.py__init__Parser.__init__    s    #;/$&!2
	!-:3.:*
^^
 ))$.. )4(9(9a(91[[cT_T_3[3(9a,7,=,=i,=q#\g\gss,=i"&%%D{{$"2"22AIAUAUVZVaVaAb0cAbAAb0c  - &&.4<<3H3H3T*:' & ??%%0T5L5L5T11===.>D+ 2
 )/ bi
 1ds   ##I

I,#I
I3Ic                 
   0 n0 nX1   n[        U5      nU(       Ga"  UR                  5       n	U	R                  (       Gar  U	R                  c  U	R                  U	R
                  U4n
X;   a  XZ   OUR                  XR                  " U
6 5      U	l        U	R                  R                  U	R                  U	R                  U	R
                  SS5        U	R                  R                  XIR
                     ;   Ga@  XIR
                     U	R                     nUR                  XKR                     ;   a  XKR                     UR                     nOUn[        UR                  UR                  UR
                  5      nUR                  UR
                  U4n
X;   a  XZ   OUR                  XR                  " U
6 5      Ul        UR                  R                  XR                  5        UR                   U R"                  ;   a  UR%                  U5        GO(X;  a"  UR%                  U5        UR'                  U5        GOU	R
                  U:H  nU(       a"  U	R                  XiR                  R                  '   X9R
                      Vs/ s H/  oR                   c  M  UR                   U	R                  :X  d  M-  UPM1     nnU H  nUR)                  5       nUR                  UR
                  U4n
X;   a  XZ   OUR                  XR                  " U
6 5      Ul        UR                  R                  UR                  UR                  XR                  U	R                  5        UR                   U R"                  ;   a  UR%                  U5        M  X;  d  M  UR%                  U5        UR'                  U5        M     GOU	R                   U R*                  ;   Gah  / nU R,                  U	R                       H!  n[        USU5      nUR'                  U5        M#     U	R                   U;   a  U	R)                  5       nUR                  U	R
                  U4n
X;   a  XZ   OUR                  XR                  " U
6 5      Ul        UR                  R                  UR                  UR                  UR
                  U	R                  XiR                      5        UR'                  U5        U HY  nUR                   U R"                  ;   a  UR%                  U5        M0  X;  d  M7  UR%                  U5        UR'                  U5        M[     U(       a  GM!  ggs  snf )at  The core Earley Predictor and Completer.

At each stage of the input, we handling any completed items (things
that matched on the last cycle) and use those to predict what should
come next in the input stream. The completions and any predicted
non-terminals are recursively processed until we reach a set of,
which can be added to the scan list for the next scanner cycle.Nr   )r   popis_completenodesstart
setdefaultr   
add_familyr6   r4   previouscolumnr   ptradd_pathexpectr1   addappendadvancer2   r-   )r;   ito_scancolumnstransitives
node_cacheheld_completionsrM   itemsitemlabel
transitiveroot_transitivenew_itemis_empty_item
originatororiginators	new_itemsr6   s                      rA   predict_and_completeParser.predict_and_completeN   s{    
f99;D 99$!VVTZZ3E5:5H
 1jNcNcdikzkz  }B  lC  ODDIII((DJJdS
 99##{::'>>!,ZZ!8!@J!**k:K:K.LL*56G6G*HI\I\*]*4#JOOZ^^ZEUEUVH,..0E0EqIE9>9LJ$5R\RgRghmo~o~  AF  pG  SHHMMM**?IIF$..8H-!/

8,X. %)JJ!OM$=AYY()9)9:@G

@S  #V@S*WhWh:  zD  zK  zK  OS  OU  OU  zU:@SK  #V&1
#-#5#5#7!)Z-=-=q A=B=P
(9V`VkVklq  tC  tC  EJ  tK  WL 00X]]A`d`i`ij#??dnn<#KK1%3"JJx0!LL2 '2  2 22	 ,,T[[9D#D!Q/H$$X. :
 ;;"22#||~H%ZZQ7E9>9LJ$5R\RgRghmo~o~  AF  pG  SHHMMM,,XZZX\XaXacstt  dA  B$$X. )H$..8H-!/

8,X. !*O eT #Vs   <T?T?,T?Nc                   ^ ^^^
^^ U U4S jnUU
U UU4S jnT R                   m
T R                  R                  m0 /mU Vs1 s H  owR                  iM     nnSnUR	                  U5       HS  n	T R                  WUTT5        U" XyU5      nUS-  nUR                  5         X Vs1 s H  owR                  iM     sn-  nMU     T R                  WUTT5        U[        T5      S-
  :X  d   eU$ s  snf s  snf )Nc                 >  > U R                   (       a  gU R                  5       nUR                   (       di  UR                  TR                  ;  a  gUR                  R
                  T:X  a  UR                  T:X  a  gUR                  5       nUR                   (       d  Mi  g)NTF)rF   rS   rP   r+   r6   r4   )r[   quasir;   start_symbols     rA   is_quasi_complete(Parser._parse.<locals>.is_quasi_complete   st    LLNE''<<t}}4 ::$$49U  '''     c           	        > TR                  5       nTR                  5       nTR                  U5        TR                  0 5        0 nTR                  U5       GH6  nT" UR                  U5      (       d  M  UR                  5       nUR                  UR
                  U 4n[        U[        5      (       a  TR                  UR                  5      OSn	[        XSS9n
X;   a  XX   OUR                  UTR                  " U6 5      Ul        UR                  R                  UR                  UR                  UR
                  UR                  U
5        UR                  TR                   ;   a  UR#                  U5        GM%  UR#                  U5        GM9     U(       dP  U(       dI  U V s1 s H  o R                  R$                  iM     nn ['        X[)        U5      [+        S U 5       5      S9eU$ s  sn f )a@  The core Earley Scanner.

This is a custom implementation of the scanner that uses the
Lark lexer to match tokens. The scan list is built by the
Earley predictor, based on the previously completed tokens.
This ensures that at each phase of the parse we have a custom
lexer context, allowing for more complex ambiguities.Nr   )r8   c              3   8   #    U  H  oR                   v   M     g 7fNrH   .0rT   s     rA   	<genexpr>.Parser._parse.<locals>.scan.<locals>.<genexpr>   s     cyqxlmdgdgqx   )considered_rulesstate)r)   rR   rP   rS   rH   rI   
isinstancer
   gettyper   rJ   r   rG   rK   r6   r1   rQ   namer   r(   	frozenset)rT   tokenrU   next_to_scannext_setrX   r[   r_   r\   r@   
token_noderP   rV   matchr;   r:   rW   s               rA   scanParser._parse.<locals>.scan   s     88:LxxzHNN8$r"J)e,,#||~H%ZZ;E 9C5%8P8P9==4VZD
 "+5!CJ9>9LJ$5R\RgRghmoso~o~  AF  pG  SHHMMM,,XZZHNNTXT]T]_ij$..8$((2 !X.+ *. L189A((--9%ec'lZccyqxcyZyzz :s   $G+r   r   )r"   r   terminals_by_namerP   lexrd   clearlen)r;   lexerrV   rU   ri   rj   r   rT   expectsr}   r   r:   rW   s   ` ` `     @@@rA   _parseParser._parse   s    	 )	  )	 Z !!OO55	 d &--W88W-YYw'E%%a';G1W-GFAMMO'2'Q'22G ( 	!!!Wg{C CLN""" . 3s   C,$C1c                   ^ U(       d   U5       e[        U5      mU R                  5       /nU R                  5       nU R                  T    HQ  n[        USS5      nUR                  U R
                  ;   a  UR                  U5        M=  US   R                  U5        MS     U R                  XUT5      n[        U4S jUS    5       5      nU(       d?  U Vs/ s H  oR                  R                  PM     n	n[        U	[        S U 5       5      S9eU R                  (       a8  SSKJn
   U
" 5       n[        U5       H  u  pUR!                  USU S	35        M     U R(                  b  U R*                  (       + n[-        U R(                  U R.                  U R0                  =(       a    U R1                  5       U R*                  U5      nU Vs/ s H  oR3                  U5      PM     nn[5        U5      S:  a6  U R*                  (       d%  U R)                  SU5      nUR7                  S5        U$ US   $ US   $ s  snf ! ["         a    [$        R&                  " S
5         GNf = fs  snf )Nr   c              3      >#    U  HV  oR                   (       d  M  UR                  c  M$  UR                  T:X  d  M6  UR                  S:X  d  MH  UR                  v   MX     g 7f)Nr   )rF   rG   rH   rI   )rr   nri   s     rA   rs   Parser.parse.<locals>.<genexpr>  s_       M{!mmvPQPVPVvghgjgjnzgzv  @A  @G  @G  KL  @Lvqvv{s   A!A!A!A!A!c              3   8   #    U  H  oR                   v   M     g 7fro   rp   rq   s     rA   rs   r      s     CYQXACCQXru   )rw   r   )ForestToPyDotVisitorsppfz.pngzBCannot find dependency 'pydot', will not generate sppf debug image_ambig)r   r)   r-   r   rP   r1   rQ   r   r   r{   r   r|   r!   earley_forestr   	enumeratevisitImportErrorr   warningr   r#   r   r,   r3   	transformr   expand_kids_by_data)r;   r   rI   rV   rU   r6   r[   	solutionstexpected_terminalsr   debug_walkerrT   rH   	use_cachetransformerri   s                   @rA   parseParser.parse  s+   eu"5)88:,((*
 $$\2Da#D{{dnn,D!
t$ 3 ++eg|D
   Mwr{  M  M	9@!AA((--!A 2)CYQXCY:YZZ::;:35 &i0DA &&qD4.9 1 99  !222I+DIIt~~tG^G^G|cgczczc|  C  U  U  W`  aK;DE9a..q19IE9~!$*@*@))Hi8%%h/Q< |= "B  ecde Fs   H5)H: 
I!: II)r*   r2   r+   r)   r   r1   r   r,   r!   r3   r   r    r-   r#   r"   ro   )__name__
__module____qualname____firstlineno____annotations__boolr   r   r   strr   r   rB   rd   r   r   __static_attributes__ rl   rA   r   r      s    K *.5BF[_+); +)\ +)Ya +)$(+)6:+)%hT{C/?&@A+)VZ+)\[/zZx6rl   r   N)$__doc__typingr   r   r   r   r   collectionsr   r   r
   treer   
exceptionsr   r   utilsr   r   r   grammar_analysisr   grammarr   earley_commonr   r   r   r   r   r   r   commonr   r   r   r   rl   rA   <module>r      sF   	 @ ?    7 2 2 - !  g g.b brl   