
    
`is                         d Z ddlZddlmZ ddlmZ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d Zd Zd Zd Zd Zd Z G d d          Z G d d          ZdS )z"Tree matcher based on Lark grammar    N)defaultdict   )TreeToken)
ParserConf)earley)RuleTerminalNonTerminalc                     | j         o| j        S N)is_term
filter_out)ts    e/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/lark/tree_matcher.pyis_discarded_terminalr      s    9%%    c                       e Zd Zd Zd ZdS )_MakeTreeMatchc                 "    || _         || _        d S r   )name	expansion)selfr   r   s      r   __init__z_MakeTreeMatch.__init__   s    	"r   c                 j    t          | j        |          }d|j        _        | j        |j        _        |S )NT)r   r   meta
match_treer   orig_expansion)r   argsr   s      r   __call__z_MakeTreeMatch.__call__   s.    D!!  $r   N)__name__
__module____qualname__r   r     r   r   r   r      s2        # # #    r   r   c                     i }| D ]>} ||          }||v r( ||          } |||                   }||k    r|||<   9|||<   ?t          |                                          S r   )listvalues)seq	group_keycmp_keyditemkeyv1v2s           r   _best_from_groupr0      s~    
A  ioo!88B3BBww#AcFF

r   c                 Z    t          | d d           } |                     d            | S )Nc                     | S r   r$   rs    r   <lambda>z(_best_rules_from_group.<locals>.<lambda>+   s    a r   c                 ,    t          | j                   S r   lenr   r3   s    r   r5   z(_best_rules_from_group.<locals>.<lambda>+   s    C<L<L;L r   c                 *    t          | j                  S r   r7   r3   s    r   r5   z(_best_rules_from_group.<locals>.<lambda>,   s    S-- r   )r-   )r0   sort)ruless    r   _best_rules_from_groupr<   *   s6    UKK1L1LMME	JJ--J...Lr   c                     t          |t                    r"t          | j                  \  }}|j        |k    S t          |t
                    r| t          |j                  k    S J | |f            r   )
isinstancer   parse_rulenamer   datar   r
   type)termtokenr   _argss       r   _matchrE   0   sl    % ,$TY//ezT!!	E5	!	! ,x
++++4-5r   c                 L    t          | |t          | j        |                    S )Nalias)r	   r   r   )originr   old_expansions      r   make_recons_rulerK   9   s#    	])S)STTTTr   c                 L    t          | t          |j                  g|g          S r   )rK   r
   r   )rI   rB   s     r   make_recons_rule_to_termrM   =   s#    FXdi%8%8$9D6BBBr   c                     t          j        d|                                           \  }}|od |                    d          D             }||fS )zJParse rule names that may contain a template syntax (like rule{a, b, ...})z(\w+)(?:{(.+)})?c                 6    g | ]}|                                 S r$   )strip).0as     r   
<listcomp>z"parse_rulename.<locals>.<listcomp>D   s     @@@q@@@r   ,)rematchgroupssplit)sr   args_strr   s       r   r?   r?   A   sS    X1155<<>>ND(@@@HNN3,?,?@@@D:r   c                       e Zd Zd Zd ZdS )ChildrenLexerc                     || _         d S r   children)r   r_   s     r   r   zChildrenLexer.__init__J   s     r   c                     | j         S r   r^   )r   parser_states     r   lexzChildrenLexer.lexM   s
    }r   N)r!   r"   r#   r   rb   r$   r   r   r\   r\   I   s2        ! ! !    r   r\   c                   $    e Zd ZdZd Zd Zd ZdS )TreeMatcherzMatch the elements of a tree node, based on an ontology
    provided by a Lark grammar.

    Supports templates and inlined rules (`rule{a, b,..}` and `_rule`)

    Initialize with an instance of Lark.
    c                    |j         j        rJ |j                            |j         j        t                                \  | _        }}t          t                    | _	        t          | 
                    |                    | _        | j                                         t          | j                  | _        || _        i | _        d S r   )optionsmaybe_placeholdersgrammarcompilestartsettokensr   r&   rules_for_root_build_recons_rulesr;   reverser<   parser_parser_cache)r   rp   r;   _extras       r   r   zTreeMatcher.__init__Y   s    >4444%+^%;%;FN<PRURWRW%X%X"UF)$//$22599::

 ,DJ77
r   c              #     K   d |D             t          t                    |D ].}|j        r%|j                                     |j                   /d |D             }fd|D             t                      }|D ]}fd|j        D             }||j        gk    r|j        *|j        rt          |j                  n|j        }t          |||j                  }|v rnt          |          dk    r[| j
        |j                                     |           |j        |vr,t          ||          V  |                    |j                   |j                            d          s|v r|V  | j
        |j                                     |                                           D ];\  }}	|	D ]!}
t          |t          |
                    V  "t          ||          V  <dS )z>Convert tree-parsing/construction rules to tree-matching rulesc                 4    h | ]}|j         j        |j        S r$   )rf   expand1rI   rQ   r4   s     r   	<setcomp>z2TreeMatcher._build_recons_rules.<locals>.<setcomp>l   s$    AAAqy/@AAHAAAr   c                     h | ]	}|j         
S r$   )rI   rv   s     r   rw   z2TreeMatcher._build_recons_rules.<locals>.<setcomp>s   s    ...1ah...r   c                 X    h | ]&}|j                             d           s|v s|v $|'S )_)r   
startswith)rQ   symaliasesexpand1ss     r   rw   z2TreeMatcher._build_recons_rules.<locals>.<setcomp>t   sN     Z Z Z8..s33Z7:h#QX.. JX..r   c                 b    g | ]+}t          |          |v r|nt          |j                  ,S r$   )r   r
   r   )rQ   r|   nonterminalss     r   rS   z3TreeMatcher._build_recons_rules.<locals>.<listcomp>y   sU     T T T!8Mc8R8RT!4!4##(38:L:L T T Tr   Nr   rz   )r   r&   rH   rI   appendrk   r   r   rK   r8   rm   r   rM   addr{   items)r   r;   r4   
rule_namesseen
recons_expr|   rulerI   rule_aliasesrH   r}   r~   r   s              @@@r   rn   zTreeMatcher._build_recons_rulesj   sh     AAeAAAd## 	2 	2Aw 2!((111.....
Z Z Z Z Zz Z Z Z uu 	? 	?AT T T T%&[T T TJ ahZ''AGO*+'?+ag&&&qxC#CQ[AADh3z??a#7#7#CH-44T:::84''23<<<<<HHSX&&&8&&s++ ?shJJJJ'188>>>>$+MMOO 	; 	; FL% K K.v{57I7IJJJJJJ*66::::::	; 	;r   c                    |r t          |          \  }}|j        |k    sJ n|j        }	 | j        |         }n# t          $ rt | j        t          | j        |                   z   }d |D             }t          |||g          }t          j	        | j
        j        |t          d          }|| j        |<   Y nw xY w|                    t          |j                  |          }	|	j        |k    sJ |	S )a  Match the elements of `tree` to the symbols of rule `rulename`.

        Parameters:
            tree (Tree): the tree node to match
            rulename (str): The expected full rule name (including template args)

        Returns:
            Tree: an unreduced tree that matches `rulename`

        Raises:
            UnexpectedToken: If no match was found.

        Note:
            It's the callers' responsibility match the tree recursively.
        c                     i | ]
}||j         S r$   rG   )rQ   r   s     r   
<dictcomp>z*TreeMatcher.match_tree.<locals>.<dictcomp>   s    <<<dtz<<<r   T)resolve_ambiguity)r?   r@   rq   KeyErrorr;   r<   rm   r   r   Parserrp   
lexer_confrE   parser\   r_   )
r   treerulenamer   rD   rp   r;   	callbacksconfunreduced_trees
             r   r   zTreeMatcher.match_tree   s      	!(22KD%9$$$$$yH		2'1FF 	2 	2 	2J!78KH8U!V!VVE =<e<<<IeY
;;D]4;#94[_```F+1Dx(((	2  mDM&B&BHMM"h....s   9 A;B76B7N)r!   r"   r#   __doc__r   rn   r   r$   r   r   rd   rd   P   sL              "(; (; (;T& & & & &r   rd   )r   rU   collectionsr    r   r   commonr   parsersr   rh   r	   r
   r   r   r   r0   r<   rE   rK   rM   r?   r\   rd   r$   r   r   <module>r      s{   ( ( 				 # # # # # #                     0 0 0 0 0 0 0 0 0 0& & &	 	 	 	 	 	 	 	         U U UC C C         j j j j j j j j j jr   