
    
`i/                     D   d Z ddlmZ ddlZddlmZ ddlmZ ddlm	Z	 ddl
mZmZmZ d	 Z G d
 d          Z G d d          Z G d d          Z G d d          Zd"dZd Z G d d          Z G d de          Zd Zd Zd Zd Zd Zd Zd Zd Z d  Z!d! Z"dS )#z$This module implements a CYK parser.    )defaultdictN   )
ParseError)Token)Tree)TerminalNonTerminalSymbolc                 P    t          | t                    sJ | j        |j        k    S N)
isinstanceTnametype)tss     d/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/lark/parsers/cyk.pymatchr      s'    a6QV    c                   @     e Zd ZdZ fdZd Zd Zd Zd Zd Z	 xZ
S )RulezContext-free grammar rule.c                    t          t          |                                            t          |t                    s
J |            t          d |D                       s
J |            || _        || _        || _        || _	        d S )Nc              3   j   K   | ].}t          |t                    pt          |t                    V  /d S r   )r   NTr   .0xs     r   	<genexpr>z Rule.__init__.<locals>.<genexpr>   s;      FFQ:a$$8
1a(8(8FFFFFFr   )
superr   __init__r   r   alllhsrhsweightalias)selfr"   r#   r$   r%   	__class__s        r   r    zRule.__init__   s    dD""$$$#r""''C''"FF#FFFFFKKKKF


r   c                 x    t          | j                  dd                    d | j        D                       S )Nz ->  c              3   4   K   | ]}t          |          V  d S r   strr   s     r   r   zRule.__str__.<locals>.<genexpr>"   s(      4N4NSVV4N4N4N4N4N4Nr   )r,   r"   joinr#   r&   s    r   __str__zRule.__str__!   s9     ]]]]CHH4N4NTX4N4N4N,N,N,NOOr   c                      t          |           S r   r+   r.   s    r   __repr__zRule.__repr__$       4yyr   c                 R    t          | j        t          | j                  f          S r   )hashr"   tupler#   r.   s    r   __hash__zRule.__hash__'   s    TXuTX/000r   c                 B    | j         |j         k    o| j        |j        k    S r   r"   r#   r&   others     r   __eq__zRule.__eq__*   s    x59$>UY)>>r   c                     | |k     S r    r9   s     r   __ne__zRule.__ne__-   s    EM""r   )__name__
__module____qualname____doc__r    r/   r1   r6   r;   r>   __classcell__r'   s   @r   r   r      s        $$    P P P  1 1 1? ? ?# # # # # # #r   r   c                   *    e Zd ZdZd Zd Zd Zd ZdS )GrammarzContext-free grammar.c                 .    t          |          | _        d S r   )	frozensetrules)r&   rI   s     r   r    zGrammar.__init__4   s    u%%


r   c                 "    | j         |j         k    S r   )rI   r9   s     r   r;   zGrammar.__eq__7   s    zU[((r   c                 p    dd                     t          d | j        D                                 z   dz   S )N
c              3   4   K   | ]}t          |          V  d S r   )reprr   s     r   r   z"Grammar.__str__.<locals>.<genexpr>;   s(      &C&C1tAww&C&C&C&C&C&Cr   )r-   sortedrI   r.   s    r   r/   zGrammar.__str__:   s7    dii&C&C
&C&C&C C CDDDtKKr   c                      t          |           S r   r+   r.   s    r   r1   zGrammar.__repr__=   r2   r   N)r?   r@   rA   rB   r    r;   r/   r1   r=   r   r   rF   rF   1   sY        & & &) ) )L L L    r   rF   c                        e Zd ZdZddZd ZdS )RuleNodez@A node in the parse tree, which also contains the full rhs rule.r   c                 0    || _         || _        || _        d S r   )rulechildrenr$   )r&   rT   rU   r$   s       r   r    zRuleNode.__init__E   s    	 r   c                     dt          | j        j                  dd                    d | j        D                       dS )Nz	RuleNode(z, [z, c              3   4   K   | ]}t          |          V  d S r   r+   r   s     r   r   z$RuleNode.__repr__.<locals>.<genexpr>K   s)      EdEdQRc!ffEdEdEdEdEdEdr   z]))rN   rT   r"   r-   rU   r.   s    r   r1   zRuleNode.__repr__J   sF     '+DIM':':':':DIIEdEdVZVcEdEdEd<d<d<d<deer   Nr   )r?   r@   rA   rB   r    r1   r=   r   r   rR   rR   B   sB        JJ   
f f f f fr   rR   c                   4     e Zd ZdZ fdZd Zd Zd Z xZS )ParserzParser wrapper.c                      t          t                                                      d |D              _         fd|D             }t	          t          |                     _        d S )Nc                     i | ]}||S r=   r=   )r   rT   s     r   
<dictcomp>z#Parser.__init__.<locals>.<dictcomp>T   s    888$4888r   c                 :    g | ]}                     |          S r=   )_to_rule)r   rT   r&   s     r   
<listcomp>z#Parser.__init__.<locals>.<listcomp>U   s%    777t$$777r   )r   rZ   r    
orig_rulesto_cnfrF   grammar)r&   rI   r'   s   ` r   r    zParser.__init__R   sg    fd$$&&&88%8887777777genn--r   c                     t          |j        t                    sJ t          d |j        D                       sJ t          |j        |j        |j        j        r|j        j        nd|          S )z?Converts a lark rule, (lhs, rhs, callback, options), to a Rule.c              3   @   K   | ]}t          |t                    V  d S r   )r   r
   r   s     r   r   z"Parser._to_rule.<locals>.<genexpr>[   s,      FFQ:a((FFFFFFr   r   r$   r%   )r   originr   r!   	expansionr   optionspriority)r&   	lark_rules     r   r_   zParser._to_ruleX   s    )*B/////FF)2EFFFFFFFFi11:1B1KR9$--QR   	r   c                 b   sJ t                    t          || j                  \  }}t          fd|dt	          |          dz
  f         D                       rt          d          |dt	          |          dz
  f                  }|                     t          |                    S )z(Parses input, which is a list of tokens.c              3   .   K   | ]}|j         k    V  d S r   )r"   )r   rstarts     r   r   zParser.parse.<locals>.<genexpr>h   s)      FF!qu~FFFFFFr   r      zParsing failed.)r   _parserc   r!   lenr   _to_tree
revert_cnf)r&   	tokenizedro   tabletreesparses     `   r   rx   zParser.parsea   s    u5		i66uFFFFuaY!1C-D'EFFFFF 	0.///q#i..1,-.u5}}Z..///r   c                 l   | j         |j        j                 }g }|j        D ]v}t	          |t
                    r)|                    |                     |                     @t	          |j        t                    sJ |                    |j                   wt          |j        |          }||_        |S )z.Converts a RuleNode parse tree to a lark Tree.)ra   rT   r%   rU   r   rR   appendrs   r   r   r   rg   )r&   	rule_node	orig_rulerU   childr   s         r   rs   zParser._to_treem   s    OIN$89	' 	, 	,E%** ,e 4 45555!%*e44444
++++!8,,r   )	r?   r@   rA   rB   r    r_   rx   rs   rC   rD   s   @r   rZ   rZ   O   sk        . . . . .  
0 
0 
0      r   rZ   c                     t          | t                    rNt          d|dz  z  t          | j        j                  z              | j        D ]}t          ||dz              d S t          d|dz  z  t          | j                  z              d S )Nr)   r   rp   )	r   rR   printr,   rT   r"   rU   print_parser   )nodeindentr}   s      r   r   r   |   s    $!! 0cVaZ 3ty}#5#55666] 	+ 	+Evz****	+ 	+ 	cVaZ 3tv;;./////r   c           
         t          t                    }t          t                    }t          |           D ]\  }}|j                                        D ]\  }}t          ||          r|D ]}|||f                             |           |j        |||f         vs#|j	        |||f         |j                 j	        k     r5t          |t          |          g|j	                  |||f         |j        <   t          dt          |           dz             D ]l}	t          t          |           |	z
  dz             D ]E}t          |dz   ||	z             D ]*}
||
dz
  f}|
||	z   dz
  f}t          j        ||         ||                   D ]\  }}|j                            |j        |j        fg           D ]}||||	z   dz
  f                             |           ||         |j                 }||         |j                 }|j	        |j	        z   |j	        z   }|j        ||||	z   dz
  f         vs$|||||	z   dz
  f         |j                 j	        k     r*t          |||g|          ||||	z   dz
  f         |j        <   Ȍ,Gn||fS )z*Parses sentence 's' using CNF grammar 'g'.r$   r   rp   )r   setdict	enumerateterminal_rulesitemsr   addr"   r$   rR   r   rangerr   	itertoolsproductnonterminal_rulesget)r   grv   rw   iwterminalrI   rT   lpspan1span2r1r2r1_treer2_treerule_total_weights                     r   rq   rq      s    E E! ] ]1 /5577 	] 	]OHeXq!! ]! ] ]D1a&M%%d+++q!f55eQFmDH&=&DDD2:4!A$$PTP[2\2\2\q!fdh/	] 1c!ffqj!! { {s1vvzA~&& 	{ 	{A1q5!a%(( { {AE
AEAI'/eeElKK { {FB ! 3 7 78H" M M { {q!a%!)n-11$777"',rv"6"',rv"6,0K'.,H7>,Y) HE1a!eai.,AAA05!QUQY3H3R3YYY>FtgW^M_hy>z>z>zE1a!eai.1$(;{{{	{ %<r   c                   .     e Zd ZdZ fdZd Zd Z xZS )
CnfWrapperzkCNF wrapper for grammar.

  Validates that the input grammar is CNF and provides helper data structures.
  c                 6   t          t          |                                            || _        |j        | _        t          t                    | _        t          t                    | _        | j        D ]"}t          |j
        t                    s
J |            t          |j                  dvrt          d          t          |j                  dk    rLt          |j        d         t                    r,| j        |j        d                                      |           t          |j                  dk    rRt#          d |j        D                       r4| j        t%          |j                                               |           J |            d S )N)rp   r   zCYK doesn't support empty rulesrp   r   r   c              3   @   K   | ]}t          |t                    V  d S r   )r   r   r   s     r   r   z&CnfWrapper.__init__.<locals>.<genexpr>   s,      (J(JqAr):):(J(J(J(J(J(Jr   )r   r   r    rc   rI   r   listr   r   r   r"   r   rr   r#   r   r   rz   r!   r5   )r&   rc   rn   r'   s      r   r    zCnfWrapper.__init__   sV   j$((***]
)$//!,T!2!2 
	  
	 AaeR((++!++(15zz'' !BCCC15zzQ:aeAh#:#:#AE!H-44Q7777QUqS(J(JAE(J(J(J%J%J&uQU||4;;A>>>>au
	  
	 r   c                 "    | j         |j         k    S r   )rc   r9   s     r   r;   zCnfWrapper.__eq__   s    |u},,r   c                 *    t          | j                  S r   )rN   rc   r.   s    r   r1   zCnfWrapper.__repr__   s    DL!!!r   )r?   r@   rA   rB   r    r;   r1   rC   rD   s   @r   r   r      s`         
         $- - -" " " " " " "r   r   c                   6     e Zd ZdZ fdZd Zej        Z xZS )UnitSkipRulez@A rule that records NTs that were skipped during transformation.c                 l    t          t          |                               ||||           || _        d S r   )r   r   r    skipped_rules)r&   r"   r#   r   r$   r%   r'   s         r   r    zUnitSkipRule.__init__   s5    lD!!**3VUCCC*r   c                 \    t          |t          |                     o| j        |j        k    S r   )r   r   r   r9   s     r   r;   zUnitSkipRule.__eq__   s(    %d,,Z1CuGZ1ZZr   )	r?   r@   rA   rB   r    r;   r   r6   rC   rD   s   @r   r   r      sM        JJ+ + + + +[ [ [ }HHHHHr   r   c                    g }t          | t                    r
|| j        z  }|                    |           t          |t                    r
||j        z  }t          | j        |j        || j        |j        z   | j                  S )Nrf   )r   r   r   rz   r"   r#   r$   r%   )	unit_ruletarget_ruler   s      r   build_unit_skipruler      s    M)\** 100%%%+|,, 322	{&-0BB)/[ [ [ [r   c                     | j         D ]>}t          |j                  dk    r$t          |j        d         t                    r|c S ?dS )zDReturns a non-terminal unit rule from 'g', or None if there is none.rp   r   N)rI   rr   r#   r   r   )r   rT   s     r   get_any_nt_unit_ruler      sJ      tx==A*TXa[""="=KKK4r   c                     fd| j         D             }fd| j         D             }|fd|D             z  }t          |          S )zFRemoves 'rule' from 'g' without changing the language produced by 'g'.c                      g | ]
}|k    |S r=   r=   r   r   rT   s     r   r`   z%_remove_unit_rule.<locals>.<listcomp>   s    111qqDyyyyyr   c                 @    g | ]}|j         j        d          k    |S rX   r8   r   s     r   r`   z%_remove_unit_rule.<locals>.<listcomp>   s+    777!!%48A;"6"6A"6"6"6r   c                 0    g | ]}t          |          S r=   )r   )r   refrT   s     r   r`   z%_remove_unit_rule.<locals>.<listcomp>   s$    AAAS%dC00AAAr   )rI   rF   )r   rT   	new_rulesrefss    `  r   _remove_unit_ruler      sf    1111AG111I7777qw777DAAAADAAAAI9r   c           
   #   |  K   t          | j                  dz   d                    d | j        D                       z   }d|z  dz   }t	          | j        | j        d         t          |dz            g| j        | j                  V  t          dt          | j                  d	z
            D ]G}t	          t          ||z            | j        |         t          ||dz   z            gdd
          V  Ht	          t          |t          | j                  d	z
  z            | j        dd         dd
          V  dS )z4Splits a rule whose len(rhs) > 2 into shorter rules.___c              3   4   K   | ]}t          |          V  d S r   r+   r   s     r   r   z_split.<locals>.<genexpr>  s(      .H.H!s1vv.H.H.H.H.H.Hr   z__SP_%sz_%dr   rp   rf   r   SplitN)
r,   r"   r-   r#   r   r   r$   r%   r   rr   )rT   rule_str	rule_namer   s       r   _splitr      s?     48}}t#chh.H.Htx.H.H.H&H&HHHX&.I
tx$(1+r)a-'8'89$+UYU_
`
`
````1c$(mma'(( g g2i!m$$tx{ByAE7J4K4K&LUV^efffffff
r)s48}}q0122DHRSSM!SZ
[
[
[[[[[[r   c           	         d | j         D             }d |D             g }| j         D ]Ɋt          j                  dk    rt          d j        D                       r|fdj        D             }|                    t          j        |j        j                             |	                    fd
                                D                        |                               t          |          S )z/Applies the TERM rule on 'g' (see top comment).c                 P    h | ]#}|j         D ]}t          |t                    |$S r=   )r#   r   r   )r   rT   r   s      r   	<setcomp>z_term.<locals>.<setcomp>  s6    III4DHIIq
1a8H8HIQIIIIr   c                 r    i | ]4}|t          t          d t          |          z            |gdd          5S )z__T_%sr   Termrf   )r   r   r,   )r   r   s     r   r]   z_term.<locals>.<dictcomp>  s@    ZZZqq$r(SVV+,,qc!6JJJZZZr   rp   c              3   @   K   | ]}t          |t                    V  d S r   )r   r   r   s     r   r   z_term.<locals>.<genexpr>  s,      $H$H!Z1%5%5$H$H$H$H$H$Hr   c                 X    g | ]&}t          |t                    r|         j        n|'S r=   )r   r   r"   )r   r   t_ruless     r   r`   z_term.<locals>.<listcomp>  s2    SSSQAq)9)9@wqz~~qSSSr   rf   c              3   4   K   | ]\  }}|j         v |V  d S r   )r#   )r   kvrT   s      r   r   z_term.<locals>.<genexpr>  s-      LL41aa48mmQmmmmLLr   )rI   rr   r#   anyrz   r   r"   r$   r%   extendr   rF   )r   all_tr   new_rhsrT   r   s       @@r   _termr   	  s   II17IIIEZZTYZZZGI # #tx==1$H$Htx$H$H$H!H!HSSSS$(SSSGT$(GDKtzZZZ[[[LLLL7==??LLLLLLLT""""9r   c                     g }| j         D ]B}t          |j                  dk    r|t          |          z  }-|                    |           Ct          |          S )z.Applies the BIN rule to 'g' (see top comment).r   )rI   rr   r#   r   rz   rF   )r   r   rT   s      r   _binr     sb    I # #tx==1%IIT""""9r   c                 j    t          |           }|r!t          | |          } t          |           }|!| S )z/Applies the UNIT rule to 'g' (see top comment).)r   r   )r   nt_unit_rules     r   _unitr   #  sD    '**L
 /a..+A..  / Hr   c                 r    t          t          t          |                               } t          |           S )z>Creates a CNF grammar from a general context-free grammar 'g'.)r   r   r   r   )r   s    r   rb   rb   ,  s'    d588nnAa==r   c                 B   |s#t          t          | |||          ||          S ||d         j        z
  }t          t          | |d         j        g||          t	          |d         j        ||dd          ||d         j        |d         j                  g|          S )Nrf   r   r   rp   )rR   r   r$   r"   unroll_unit_skipruler%   )r"   orig_rhsr   rU   r$   r%   s         r   r   r   2  s     	S(6GGGZ`aaaa-*11}Q'+,V5III$]1%5%98 -abb 18 -a 0 7q9I9OQ QL    	r   c                 l   t          | t                    r| S | j        j        j                            d          r| j        d         S g }t          t          | j                  D ][}t          |t                    r/|j        j        j                            d          r||j        z  }F|
                    |           \t          | j        t                    rFt          | j        j        | j        j        | j        j        || j        j        | j        j                  S t          | j        |          S )zDReverts a parse tree (RuleNode) to its original non-CNF form (Node).__T_r   __SP_)r   r   rT   r"   r   
startswithrU   maprt   rR   rz   r   r   r#   r   r$   r%   )r   rU   r}   s      r   rt   rt   ?  s   $ y}$$V,, 1}QT]33 	' 	'E%** 'uz~/B/M/Mg/V/V 'EN*&&&&di.. 	1'	ty}$(I$;X$(I$4dioG G G DIx000r   rX   )#rB   collectionsr   r   
exceptionsr   lexerr   treer   rc   r   r   r	   r   r
   r   r   rF   rR   rZ   r   rq   r   r   r   r   r   r   r   r   r   rb   r   rt   r=   r   r   <module>r      sS   * * $ # # # # #     # # # # # #             > > > > > > > > > >  
# # # # # # # #8       "	f 	f 	f 	f 	f 	f 	f 	f* * * * * * * *Z0 0 0 0" " "f" " " " " " " ">
 
 
 
 
4 
 
 
[ [ [    \ \ \        
 
 
1 1 1 1 1r   