o
    .d!;                     @  s  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	 ddlm
Z
 dd	lmZ dd
lmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z  ddlm!Z! ddlm"Z" ddlm#Z# dd lm$Z$ dd!lm%Z% dd"lm&Z& dd#lm'Z' dd$lm(Z( dd%lm)Z) dd&lm*Z* dd'lm+Z+ dd(lm,Z, dd)lm-Z- dd*lm.Z. dd+lm/Z/ dd,lm0Z0 dd-lm1Z1 dd.lm2Z2 dd/lm3Z3 dd0lm4Z4 dd1lm5Z5 dd2lm6Z6 dd3lm7Z7 dd4lm8Z8 dd5lm9Z9 d6Z:d7Z;d8Z<e$d9fe4e<fe!e;fed:fe%d;fe0d<fd=d>e"d?ff	Z=e/d@fe(dAfe2dBfedCfe$d9fe)dDfe4e<fe!e;fed:fedEfe%d;fe0d<fedFfe.dGfd=d>e"d?ffZ>e?e6ee*e+eegZ@edHfge>R ZAe/d@fe(dAfe2dBfedCfe$d9fe)dDfe4e<fe!dIfed:fe%d;fe0d<fedFfd=dJd>e"d?ffZBe?e6ee*e+eeee-eg	ZCedCfe$d9fe!e;fe/d@fed:fe%d;fe0d<fe(dAfe2dBfedFfd=d>e"d?ffZDe?e#e,e&e1eegZEe/d@fe(dAfe2dBfedCfe$d9fe)dDfe4e<fe!dIfed:fedEfe%d;fe0d<fedFfd=d>e"d?ffZFe?e6ee*e+eee7e eg	ZG	K	L	M	N	O	OdwdxdYdZZHdyd]d^ZI	_	Odzd{dddeZJedfdg	Od|d}didjZKeKdOdkZLd~dndoZMeeMeIe=dpdqZNeeMeIeDeEdqZOeeMeIe>e@dqZPeeMeIeAe@dqZQeeMeIeBeCdqZReeMeIeFeGdqZSeeMeIe=ehdqZTddrdsZUedfdg	K	L	M	N	O	OdwddudvZVdS )a  Tokenize Liquid templates and expressions.

The template lexer generates a stream of template literals, tags, output statements and
expressions, where each expression token is an unscanned string. Lexing of expression
tokens is delegated to the "parse" method of each registered Tag.

As of Python Liquid 1.2.0 we are in the process of refactoring and optimizing expression
tokenization. All `tokenize_*` functions and expression rules are being migrated to
`liquid.expressions`. Those defined here will be depreciated as we approach version 2.0.
At which point this module will be reserved for tokenizing templates, not expressions.

All built-in tags now use lexers (and parsers) found in the `liquid.expressions`
package.
    )annotationsN)	lru_cache)partial)Callable)
Collection)Iterable)Iterator)Pattern)Tuple)LiquidSyntaxError)	TOKEN_AND)TOKEN_AS)TOKEN_ASSIGN)TOKEN_BLANK)TOKEN_BY)TOKEN_COLON)
TOKEN_COLS)TOKEN_COMMA)TOKEN_CONTAINS)TOKEN_CONTINUE)	TOKEN_DOT)TOKEN_EMPTY)TOKEN_EXPRESSION)TOKEN_FALSE)TOKEN_FLOAT)	TOKEN_FOR)TOKEN_IDENTIFIER)TOKEN_ILLEGAL)TOKEN_IN)TOKEN_INTEGER)TOKEN_LBRACKET)TOKEN_LIMIT)TOKEN_LITERAL)TOKEN_LPAREN)TOKEN_NEGATIVE)	TOKEN_NIL)
TOKEN_NULL)TOKEN_OFFSET)TOKEN_OR)
TOKEN_PIPE)TOKEN_RANGE)TOKEN_RBRACKET)TOKEN_REVERSED)TOKEN_RPAREN)TOKEN_STATEMENT)TOKEN_STRING)	TOKEN_TAG)
TOKEN_TRUE)
TOKEN_WITH)Token)	operators)
tokenize_assignment_expressiontokenize_boolean_expressiontokenize_filtered_expressiontokenize_loop_expressiontokenize_identifiertokenize_include_expressiontokenize_paginate_expressiontokenize_liquid_expression	get_lexerget_liquid_expression_lexerz\w[a-zA-Z0-9_\-]*z)(?P<quote>[\"'])(?P<quoted>.*?)(?P=quote)z\d+z\.z\[])NEWLINEz\n)SKIPz[ \t\r]+.z\.\.z\(z\)z\d+\.(?!\.)\d*-,:z\|=z\w[a-zA-Z0-9_\-?]*)OPz[!=<>]{1,2}{%%}{{}} tag_start_stringstrtag_end_stringstatement_start_stringstatement_end_stringcomment_start_stringcomment_end_stringreturnPattern[str]c                 C  s   t | }t |}t |}t |}	t |}
t |}| d| d| d| }| d|	 }| d| }|sVd| d| d}d	|ft|fd
|ft|fg}t|S d| d| d|
 d}|
 d| }d	|fd|ft|fd
|ft|fg}t|S )z*Compile rules for lexing liquid templates.z-?\s*raw\s*(?P<rsr>-?)z(?P<raw>.*?)z-?\s*endraw\s*(?P<rsr_e>-?)z -?\s*(?P<stmt>.*?)\s*(?P<rss>-?)z;-?(?P<pre>\s*(?P<name>#|\w*)\s*)(?P<expr>.*?)\s*(?P<rst>-?)z.+?(?=((|z)(?P<rstrip>-?))|$)RAWTAGz(?P<comment>.*?)(?P<rsc>-?)COMMENT)reescaper.   r"   _compile_rules)rM   rO   rP   rQ   rR   rS   tag_stag_estmt_sstmt_e	comment_s	comment_eraw_patternstatement_patterntag_patternliteral_patternliquid_rulescomment_pattern ri   B/var/www/Matress/matenv/lib/python3.10/site-packages/liquid/lex.pycompile_liquid_rules   s@   
	




rk   rulesIterable[Tuple[str, str]]c                 C  s"   d dd | D }t|tjS )z9Compile the given rules into a single regular expression.rV   c                 s  s&    | ]\}}d | d| dV  qdS )z(?P<>)Nri   ).0namepatternri   ri   rj   	<genexpr>  s   $ z!_compile_rules.<locals>.<genexpr>)joinrZ   compileDOTALL)rl   rr   ri   ri   rj   r\     s   r\      source
line_countintIterator[Token]c           	      c  s    | | D ]H}|j}|dusJ |}| }||d7 }|dkrC|d}||kr,qt|t|V  |drBt|t|dV  q|dkrHqtd|dS )z#Tokenize a "liquid" tag expression.N
LIQUID_EXPRrq   exprrA   z2expected newline delimited tag expressions, found )finditer	lastgroupgroupcountr3   r0   r   r   )	rx   rl   ry   rR   matchkindline_numvaluerq   ri   ri   rj   _tokenize_liquid_expression(  s*   

r      )maxsizeCallable[..., Iterator[Token]]c                 C  sV   |  dd} | rt| }dd| dfdtdff}nddtdff}ttt|| d	S )
zGReturn a tokenizer that yields tokens from a `liquid` tag's expression.{rL   r}   z[ \t]*(?P<name>(\w+|z%))[ \t]*(?P<expr>.*?)[ \t\r]*?(\n+|$))rA   z[\r\n]+rB   )r}   z8[ \t]*(?P<name>#|\w+)[ \t]*(?P<expr>.*?)[ \t\r]*?(\n+|$))rl   rR   )replacerZ   r[   r   r   r   r\   )rR   commentrl   ri   ri   rj   r>   H  s$   


r>   )rR   keywordsCollection[str]c                 c  s    d}| | D ]g}|j}|dusJ | }|tkr"||v r"|}nF|tkr,|d}n<|dkrMzt| }W n1 tyL } z
td||d|d}~ww |dkrV|d7 }q|dkr[q|tkrhtd	||dt	|||V  qdS )
zMGenerate tokens from the given source string according to the compiled rules.rw   NquotedrG   zunknown operator linenumr@   rA   zunexpected )
r   r   r   r   r/   r4   KeyErrorr   r   r3   )rx   rl   r   r   r   r   r   errri   ri   rj   	_tokenizem  s>   r   ri   )rl   r   c           	      c  sh   d}d}| | D ]}|j}|d usJ |}| }||d7 }|tkr3|d}t|d}nw|dkr_|d}t|t|V  t}|d}||d	d7 }t|d
}|s^q
nK|dkrkt|d}q
|dkr~t	}|d}t|d}n,|t	kr|r|
 }|dr| }|sq
|drtd|d|drtd|dt|||V  q
d S )Nrw   Fr|   stmtrssrX   rq   r~   prerstrY   rscrW   rawrsr_erstriprJ   zexpected '}}', found 'eof'r   rH   zexpected '%}', found 'eof')r   r   r   r   r.   boolr3   r0   r   r"   lstripr   
startswithr   )	rx   rl   ry   r   r   r   r   r   rq   ri   ri   rj   _tokenize_template  s\   






r    Callable[[str], Iterator[Token]]c                 C  s   t | |||||}tt|dS )zEReturn a template lexer using the given tag and statement delimiters.)rl   )rk   r   r   )rM   rO   rP   rQ   rR   rS   rl   ri   ri   rj   r=     s   
r=   )rH   rI   rJ   rK   rL   rL   )rM   rN   rO   rN   rP   rN   rQ   rN   rR   rN   rS   rN   rT   rU   )rl   rm   rT   rU   )rw   rL   )
rx   rN   rl   rU   ry   rz   rR   rN   rT   r{   )rL   )rR   rN   rT   r   )rx   rN   rl   rU   r   r   rT   r{   )rx   rN   rl   rU   rT   r{   )rM   rN   rO   rN   rP   rN   rQ   rN   rR   rN   rS   rN   rT   r   )W__doc__
__future__r   rZ   	functoolsr   r   typingr   r   r   r   r	   r
   liquid.exceptionsr   liquid.tokenr   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r    r!   r"   r#   r$   r%   r&   r'   r(   r)   r*   r+   r,   r-   r.   r/   r0   r1   r2   r3   r4   __all__IDENTIFIER_PATTERNSTRING_PATTERNidentifier_rulesfiltered_expression_rules	frozensetfiltered_expression_keywordsassignment_expression_rulesboolean_expression_rulesboolean_expression_keywordsloop_expression_rulesloop_expression_keywordsinclude_expression_rulesinclude_expression_keywordsrk   r\   r   r>   r<   r   r9   r8   r7   r5   r6   r:   r;   r   r=   ri   ri   ri   rj   <module>   s   
8 
!
(
;