
    biv                         d Z ddlZddlmZmZ ddlmZ ddlmZm	Z	m
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d Zdee   dee   fdZd Zd Zd Zd Z G d d      Z G d d      Zy)z"Tree matcher based on Lark grammar    N)ListDict)defaultdict   )TreeTokenLark)
ParserConf)ConfigurationError)earley)RuleTerminalNonTerminalc                 6    | j                   xr | j                  S N)is_term
filter_out)ts    L/home/cdr/jupyterlab/.venv/lib/python3.12/site-packages/lark/tree_matcher.pyis_discarded_terminalr      s    99%%    c                       e Zd Zd Zd Zy)_MakeTreeMatchc                      || _         || _        y r   )name	expansion)selfr   r   s      r   __init__z_MakeTreeMatch.__init__   s    	"r   c                     t        | j                  |      }d|j                  _        | j                  |j                  _        |S )NT)r   r   meta
match_treer   orig_expansion)r   argsr   s      r   __call__z_MakeTreeMatch.__call__   s3    D!  $r   N)__name__
__module____qualname__r   r$    r   r   r   r      s    #r   r   c                     i }| D ]2  } ||      }||v r ||      } |||         }||kD  s(|||<   .|||<   4 t        |j                               S r   )listvalues)seq	group_keycmp_keyditemkeyv1v2s           r   _best_from_groupr4      sh    
A o!8B3BBw#AcF 
r   rulesreturnc                 J    t        | d d       } | j                  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   r9   s    r   r;   z(_best_rules_from_group.<locals>.<lambda>-   s    C<L;L r   c                 ,    t        | j                        S r   r=   r9   s    r   r;   z(_best_rules_from_group.<locals>.<lambda>.   s    S- r   )r1   )r4   sort)r5   s    r   _best_rules_from_grouprA   ,   s%    UK1L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   _matchrJ   2   sY    %$TYY/ezzT!!	E5	!x

+++4-5r   c                 F    t        | |t        | j                  |            S )N)alias)r   r   r   )originr   old_expansions      r   make_recons_rulerO   ;   s    	])STTr   c                 F    t        | t        |j                        g|g      S r   )rO   r   r   )rM   rG   s     r   make_recons_rule_to_termrQ   ?   s    FXdii%8$9D6BBr   c                     t        j                  d|       j                         \  }}|xr- |j                  d      D cg c]  }|j	                          c}}||fS c c}w )zJParse rule names that may contain a template syntax (like rule{a, b, ...})z(\w+)(?:{(.+)})?,)rematchgroupssplitstrip)sr   args_strar#   s        r   rD   rD   C   sT    XX115<<>ND(@HNN3,?@q@D: As   Ac                       e Zd Zd Zd Zy)ChildrenLexerc                     || _         y r   children)r   r`   s     r   r   zChildrenLexer.__init__L   s	     r   c                     | j                   S r   r_   )r   parser_states     r   lexzChildrenLexer.lexO   s    }}r   N)r%   r&   r'   r   rc   r(   r   r   r]   r]   K   s    !r   r]   c                   x    e Zd ZU dZeeee   f   ed<   ee   ed<   e	ed<   de	fdZ
dee   fdZdeded	efd
Zy)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.
    rules_for_rootr5   parserc                    |j                   j                  rJ |j                   j                  r|j                   j                  j                  rut	        |d      s't        |j                   j                  rd      d      |j                  j                  |j                   j                  t                     \  | _        }}n/t        |j                        | _        t        |j                        }t        t              | _        t        | j#                  |            | _        | j                  j%                          t'        | j                        | _        || _        i | _        y )NgrammarzGSource grammar not available from cached parser, use cache_grammar=TruezSource grammar not available!)optionsmaybe_placeholderspostlexalways_accepthasattrr   cacheri   compilestartsettokensr*   	terminalsr5   r   rf   _build_recons_rulesreverserA   rg   _parser_cache)r   rg   r5   _extras       r   r   zTreeMatcher.__init__^   s   >>4444>>!!fnn&<&<&J&J69-(,2NN,@,@ *s g gFeg g)/)?)?@T@TVYV[)\&DKv//0DK&E)$/$2259:


 ,DJJ7
79r   c              #   ,  K   |D ch c]%  }|j                   j                  s|j                  ' }}t        t              }|D ]7  }|j
                  s||j                     j                  |j
                         9 |D ch c]  }|j                   }}|D ch c]'  }|j                  j                  d      s||v s||v r|) }}t               }|D ]b  }|j                  D cg c](  }t        |      s||v r|nt        |j                        * }	}|	|j                  gk(  r|j
                  ^|j
                  rt        |j
                        n|j                  }t        ||	|j                        }
||v rpt        |	      dk7  rb| j                   |j                     j                  |
       |j                  |vst#        ||       |j%                  |j                         |j                  j                  d      s||v r|
 ;| j                   |j                     j                  |
       e |j'                         D ]1  \  }}|D ]  }t#        |t        |              t#        ||       3 yc c}w c c}w c c}w c c}w w)z>Convert tree-parsing/construction rules to tree-matching rules_Nr   )rj   expand1rM   r   r*   rL   appendr   
startswithrr   r   r   r   r   rO   r>   rf   rQ   additems)r   r5   r:   expand1saliases
rule_namessymnonterminalsseen
recons_exprulerM   rule_aliasesrL   s                 r   ru   zTreeMatcher._build_recons_rulesw   sQ    &+Aqyy/@/@AHHAAd# 	2Aww!((1	2 )..1ahh.
.'1 Z88..s3sh#QX.  Z Z u 	?A%&[[T!8Mc8R "%!4#(388:LL TJ T ahhZ'AGGO*+''+agg&qxxC#CQ[[ADh3z?a#7##CHH-44T:884'23<<HHSXX&88&&s+shJ''188>+	?. %,MMO 	; FL% K.v{57IJJK*66::	;G B /Z
TsF   JJ J "J.JJJ,J
 J'-JB+J CJtreerulenamer6   c                 0   |rt        |      \  }}|j                  |k(  sJ |j                  }	 | j                  |   }|j                  t        |j                         |      }
|
j                  |k(  sJ |
S # t        $ r | j                  t        | j                  |         z   }|D ci c]  }||j                   nc c}w }}t        |||g      }	t        j                  | j                  j                  |	t        d      }|| j                  |<   Y w xY w)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 to match the tree recursively.
        T)resolve_ambiguity)rD   rE   rw   KeyErrorr5   rA   rf   rL   r
   r   Parserrg   
lexer_confrJ   parser]   r`   )r   r   r   r   rI   rg   r5   r   	callbacksconfunreduced_trees              r   r!   zTreeMatcher.match_tree   s
     (2KD%99$$$yyH		2''1F  &||M$--,H(S""h...  	2JJ!78K8KH8U!VVE 7<<dtzz)<<I<eY
;D]]4;;#9#94[_`F+1Dx(	2s   A6 62D(B=<ADDN)r%   r&   r'   __doc__r   strr   r   __annotations__r	   r   ru   r   r!   r(   r   r   re   re   R   sb     d4j)):L:t :2(;d (;T&t &s &t &r   re   )r   rT   typingr   r   collectionsr    r   r   r	   commonr
   
exceptionsr   parsersr   ri   r   r   r   r   r   r4   rA   rJ   rO   rQ   rD   r]   re   r(   r   r   <module>r      s    ( 	  #    *  0 0&	 	$t* d  UC u ur   