%PDF- %PDF-
Mini Shell

Mini Shell

Direktori : /snap/core20/2582/lib/python3/dist-packages/jinja2/__pycache__/
Upload File :
Create Path :
Current File : //snap/core20/2582/lib/python3/dist-packages/jinja2/__pycache__/lexer.cpython-38.pyc

U

��g�o�@s�dZddlZzddlmZWnddlmZYnXddlmZddlmZm	Z	m
Z
mZddlm
Z
ddlmZed�Ze�d	ej�Ze�d
ej�Ze�d�Zzedd
d�Wn"ek
r�e�d�ZdZYnBXddlmZe�d�ej��ZdZddlZejd=ddlZe`[e�d�Z e�d�Z!e	d�Z"e	d�Z#e	d�Z$e	d�Z%e	d�Z&e	d�Z'e	d�Z(e	d�Z)e	d�Z*e	d �Z+e	d!�Z,e	d"�Z-e	d#�Z.e	d$�Z/e	d%�Z0e	d&�Z1e	d'�Z2e	d(�Z3e	d)�Z4e	d*�Z5e	d+�Z6e	d,�Z7e	d-�Z8e	d.�Z9e	d/�Z:e	d0�Z;e	d1�Z<e	d2�Z=e	d3�Z>e	d4�Z?e	d5�Z@e	d6�ZAe	d7�ZBe	d8�ZCe	d9�ZDe	d:�ZEe	d;�ZFe	d<�ZGe	d=�ZHe	d>�ZIe	d?�ZJe	d@�ZKe	dA�ZLe	dB�ZMe	dC�ZNe	dD�ZOe	dE�ZPe	dF�ZQe	dG�ZRe"e:e&e)e2e1e5e;e-e7e.e8e,e6e(e3e*e+e/e0e#e'e$e4e%e9dH�ZSeTdIdJ�e
eS�D��ZUeVeS�eVeU�k�stWdK��e�dLdM�XdNdO�eYeSdPdQ�dR�D���ZZe[eHeJeIe<eMeNeOg�Z\e[e<ePeJeOg�Z]dSdT�Z^dUdV�Z_dWdX�Z`dYdZ�Zad[d\�ZbGd]d^�d^ec�ZdGd_d`�d`ee�ZfeGdadb�dbec��ZgeGdcdd�ddec��Zhdedf�ZiGdgdh�dhec�ZjdS)ia�
    jinja2.lexer
    ~~~~~~~~~~~~

    This module implements a Jinja / Python combination lexer. The
    `Lexer` class provided by this module is used to do some preprocessing
    for Jinja.

    On the one hand it filters out invalid operators like the bitshift
    operators we don't allow in templates. On the other hand it separates
    template code and python code in expressions.

    :copyright: (c) 2017 by the Jinja Team.
    :license: BSD, see LICENSE for more details.
�N)�deque)�
itemgetter)�implements_iterator�intern�	iteritems�	text_type)�TemplateSyntaxError)�LRUCache�2z\s+z7('([^'\\]*(?:\\.[^'\\]*)*)'|"([^"\\]*(?:\\.[^"\\]*)*)")z\d+ufööz	<unknown>�evalz[a-zA-Z_][a-zA-Z0-9_]*F)�_identifierz[\w{0}]+Tzjinja2._identifierz(?<!\.)\d+\.\d+z(\r\n|\r|\n)�addZassignZcolonZcommaZdiv�dot�eq�floordiv�gtZgteqZlbraceZlbracketZlparen�ltZlteq�mod�mul�ne�pipe�powZrbraceZrbracketZrparenZ	semicolon�sub�tildeZ
whitespace�float�integer�name�string�operator�block_begin�	block_endZvariable_begin�variable_end�	raw_begin�raw_endZ
comment_beginZcomment_end�comment�linestatement_begin�linestatement_endZlinecomment_beginZlinecomment_end�linecomment�data�initial�eof)�+�-�/z//�*�%z**�~�[�]�(�)�{�}z==z!=�>z>=�<z<=�=�.�:�|�,�;cCsg|]\}}||f�qS�r?)�.0�k�vr?r?�./usr/lib/python3/dist-packages/jinja2/lexer.py�
<listcomp>�srDzoperators droppedz(%s)r<ccs|]}t�|�VqdS�N)�re�escape�r@�xr?r?rC�	<genexpr>�srJcCs
t|�SrE)�len�rIr?r?rC�<lambda>��rM)�keycCsL|tkrt|Stdtdtdtdtdtdtdtdt	dt
d	td
tdi�
||�S)Nzbegin of commentzend of commentr$zbegin of statement blockzend of statement blockzbegin of print statementzend of print statementzbegin of line statementzend of line statementztemplate data / textzend of template)�reverse_operators�TOKEN_COMMENT_BEGIN�TOKEN_COMMENT_END�
TOKEN_COMMENT�TOKEN_LINECOMMENT�TOKEN_BLOCK_BEGIN�TOKEN_BLOCK_END�TOKEN_VARIABLE_BEGIN�TOKEN_VARIABLE_END�TOKEN_LINESTATEMENT_BEGIN�TOKEN_LINESTATEMENT_END�
TOKEN_DATA�	TOKEN_EOF�get)�
token_typer?r?rC�_describe_token_type�s<�
�r_cCs|jdkr|jSt|j�S)z#Returns a description of the token.r)�type�valuer_)�tokenr?r?rC�describe_token�s
rccCs2d|kr&|�dd�\}}|dkr*|Sn|}t|�S)z0Like `describe_token` but for token expressions.r;�r)�splitr_)�exprr`rar?r?rC�describe_token_expr�srgcCstt�|��S)zsCount the number of newline characters in the string.  This is
    useful for extensions that filter a stream.
    )rK�
newline_re�findall)rar?r?rC�count_newlines�srjcCs�tj}t|j�d||j�ft|j�d||j�ft|j�d||j�fg}|jdk	rp|�t|j�dd||j�f�|jdk	r�|�t|j�dd||j�f�d	d
�t	|dd�D�S)
zACompiles all the rules from the environment into a list of rules.r$�block�variableNZ
linestatementz	^[ \t\v]*r'z(?:^|(?<=\S))[^\S\r\n]*cSsg|]}|dd��qS)rdNr?rHr?r?rCrD�sz!compile_rules.<locals>.<listcomp>T)�reverse)
rFrGrK�comment_start_string�block_start_string�variable_start_string�line_statement_prefix�append�line_comment_prefix�sorted)�environment�e�rulesr?r?rC�
compile_rules�s,
�
�
��	
�
��rxc@s$eZdZdZefdd�Zdd�ZdS)�FailurezjClass that raises a `TemplateSyntaxError` if called.
    Used by the `Lexer` to specify known errors.
    cCs||_||_dSrE)�message�error_class)�selfrz�clsr?r?rC�__init__�szFailure.__init__cCs|�|j||��dSrE)r{rz)r|�lineno�filenamer?r?rC�__call__�szFailure.__call__N)�__name__�
__module__�__qualname__�__doc__rr~r�r?r?r?rCry�sryc@sTeZdZdZdZdd�ed�D�\ZZZdd�Z	dd	�Z
d
d�Zdd
�Zdd�Z
dS)�TokenzToken class.r?ccs|]}tt|��VqdSrE)�propertyrrHr?r?rCrJ�szToken.<genexpr>�cCst�||tt|��|f�SrE)�tuple�__new__r�str)r}rr`rar?r?rCr��sz
Token.__new__cCs*|jtkrt|jS|jdkr$|jS|jS)Nr)r`rPra�r|r?r?rC�__str__�s



z
Token.__str__cCs2|j|krdSd|kr.|�dd�|j|jgkSdS)z�Test a token against a token expression.  This can either be a
        token type or ``'token_type:token_value'``.  This can only test
        against string values and types.
        Tr;rdF)r`rera�r|rfr?r?rC�test�s

z
Token.testcGs|D]}|�|�rdSqdS)z(Test against multiple token expressions.TF)r�)r|�iterablerfr?r?rC�test_any	s
zToken.test_anycCsd|j|j|jfS)NzToken(%r, %r, %r))rr`rar�r?r?rC�__repr__s
�zToken.__repr__N)r�r�r�r��	__slots__�rangerr`rar�r�r�r�r�r?r?r?rCr��s
r�c@s(eZdZdZdd�Zdd�Zdd�ZdS)	�TokenStreamIteratorz`The iterator for tokenstreams.  Iterate over the stream
    until the eof token is reached.
    cCs
||_dSrE)�stream)r|r�r?r?rCr~szTokenStreamIterator.__init__cCs|SrEr?r�r?r?rC�__iter__!szTokenStreamIterator.__iter__cCs0|jj}|jtkr"|j��t��t|j�|SrE)r��currentr`r\�close�
StopIteration�next�r|rbr?r?rC�__next__$s


zTokenStreamIterator.__next__N)r�r�r�r�r~r�r�r?r?r?rCr�sr�c@s~eZdZdZdd�Zdd�Zdd�ZeZedd	�d
d�Z	dd
�Z
dd�Zddd�Zdd�Z
dd�Zdd�Zdd�Zdd�ZdS)�TokenStreamz�A token stream is an iterable that yields :class:`Token`\s.  The
    parser however does not iterate over it but calls :meth:`next` to go
    one token ahead.  The current active token is stored as :attr:`current`.
    cCs>t|�|_t�|_||_||_d|_tdtd�|_	t
|�dS)NFrd�)�iter�_iterr�_pushedrr��closedr��
TOKEN_INITIALr�r�)r|�	generatorrr�r?r?rCr~4s
zTokenStream.__init__cCst|�SrE)r�r�r?r?rCr�=szTokenStream.__iter__cCst|j�p|jjtk	SrE)�boolr�r�r`r\r�r?r?rC�__bool__@szTokenStream.__bool__cCs|SrEr?rLr?r?rCrMDrNzTokenStream.<lambda>z Are we at the end of the stream?)�doccCs|j�|�dS)z Push a token back to the stream.N)r�rrr�r?r?rC�pushFszTokenStream.pushcCs"t|�}|j}|�|�||_|S)zLook at the next token.)r�r�r�)r|Z	old_token�resultr?r?rC�lookJs

zTokenStream.lookrdcCst|�D]}t|�qdS)zGot n tokens ahead.N)r�r�)r|�nrIr?r?rC�skipRszTokenStream.skipcCs|j�|�rt|�SdS)zqPerform the token test and return the token if it matched.
        Otherwise the return value is `None`.
        N)r�r�r�r�r?r?rC�next_ifWszTokenStream.next_ifcCs|�|�dk	S)z8Like :meth:`next_if` but only returns `True` or `False`.N)r�r�r?r?rC�skip_if^szTokenStream.skip_ifcCsX|j}|jr|j��|_n:|jjtk	rTzt|j�|_Wntk
rR|��YnX|S)z|Go one token ahead and return the old one.

        Use the built-in :func:`next` instead of calling this directly.
        )	r�r��popleftr`r\r�r�r�r�)r|�rvr?r?rCr�bszTokenStream.__next__cCs"t|jjtd�|_d|_d|_dS)zClose the stream.r�NT)r�r�rr\r�r�r�r?r?rCr�qszTokenStream.closecCsx|j�|�s^t|�}|jjtkr:td||jj|j|j��td|t	|j�f|jj|j|j��z
|jW�St
|�XdS)z}Expect a given token type and return it.  This accepts the same
        argument as :meth:`jinja2.lexer.Token.test`.
        z(unexpected end of template, expected %r.zexpected token %r, got %rN)r�r�rgr`r\rrrr�rcr�r�r?r?rC�expectws(����
zTokenStream.expectN)rd)r�r�r�r�r~r�r�Z__nonzero__r�Zeosr�r�r�r�r�r�r�r�r?r?r?rCr�-s	
r�cCsZ|j|j|j|j|j|j|j|j|j|j	|j
|jf}t�
|�}|dkrVt|�}|t|<|S)z(Return a lexer which is probably cached.N)ro�block_end_stringrp�variable_end_stringrn�comment_end_stringrqrs�trim_blocks�
lstrip_blocks�newline_sequence�keep_trailing_newline�_lexer_cacher]�Lexer)rurOZlexerr?r?rC�	get_lexer�s$�
r�c@s>eZdZdZdd�Zdd�Zd
dd�Zdd	d
�Zddd�ZdS)r�a
Class that implements a lexer for a given environment. Automatically
    created by the environment class, usually you don't have to do that.

    Note that the lexer is not automatically bound to an environment.
    Multiple environments can share the same lexer.
    cs�dd�}tj}ttdfttdfttdftt	dft
tdftt
dfg}t|�}|jrTdpVd}i�|j�r\|d�}|d||j��}|�|j�}	||	r�d||	�d��p�d7}|�|j�}	||	r�d||	�d��p�d7}|d||j��}
|
�|j�}	|	�r
d	||	�d���pd}d
}d|||j�|||j�f}
d|||j�|||j�f}|
�d
<|�d<nd||j�}
|j|_|j|_d|dd�d||j�|
||j�||j�fg�fdd�|D���tdfdf|d�tdfgt|d||j�||j�|f�ttfdf|d�td�fdfgt |d||j�||j�|f�t!dfg|t"|d||j#�||j#�f�t$dfg|t%|d||j�|
||j�||j�|f�tt&fdf|d�td�fdfgt'|d �t(dfg|t)|d!�t*t+fdfgi|_,dS)"NcSst�|tjtjB�SrE)rF�compile�M�SrLr?r?rCrM�rNz Lexer.__init__.<locals>.<lambda>z\n?r�r+z^%s(.*)z|%srdz(?!%s)z^[ \t]*z%s%s(?!%s)|%s\+?z%s%s%s|%s\+?rkr$z%s�rootz(.*?)(?:%s)r<z4(?P<raw_begin>(?:\s*%s\-|%s)\s*raw\s*(?:\-%s\s*|%s))c	s&g|]\}}d||��||�f�qS)z(?P<%s_begin>\s*%s\-|%s))r])r@r��r�Z	prefix_rer?rCrD�s�z"Lexer.__init__.<locals>.<listcomp>�#bygroupz.+z(.*?)((?:\-%s\s*|%s)%s)�#popz(.)zMissing end of comment tagz(?:\-%s\s*|%s)%sz
\-%s\s*|%sz1(.*?)((?:\s*%s\-|%s)\s*endraw\s*(?:\-%s\s*|%s%s))zMissing end of raw directivez	\s*(\n|$)z(.*?)()(?=\n|$))-rFrG�
whitespace_re�TOKEN_WHITESPACE�float_re�TOKEN_FLOAT�
integer_re�
TOKEN_INTEGER�name_re�
TOKEN_NAME�	string_re�TOKEN_STRING�operator_re�TOKEN_OPERATORrxr�r�ro�matchrn�grouprpr�r��joinr�r[rQr�rSrRryrUrVrWr�rX�TOKEN_RAW_BEGIN�
TOKEN_RAW_ENDrYrZ�TOKEN_LINECOMMENT_BEGINrT�TOKEN_LINECOMMENT_ENDrw)r|ru�crvZ	tag_rulesZroot_tag_rulesZblock_suffix_reZno_lstrip_reZ
block_diff�mZcomment_diffZno_variable_reZ	lstrip_reZblock_prefix_reZcomment_prefix_rer?r�rCr~�s����
�
���	�����	�����������������zLexer.__init__cCst�|j|�S)z@Called for strings and template data to normalize it to unicode.)rhrr�)r|rar?r?rC�_normalize_newlines)szLexer._normalize_newlinesNcCs&|�||||�}t|�|||�||�S)zCCalls tokeniter + tokenize and wraps it in a token stream.
        )�	tokeniterr��wrap)r|�sourcerr��stater�r?r?rC�tokenize-szLexer.tokenizec	csb|D�]V\}}}|tkrq�n0|dkr.d}�n |dkr>d}�n|dkrLq�n|dkr`|�|�}n�|dkrn|}n�|dkr�t|�}tr�|��s�td	|||��n�|d
k�rz$|�|dd���d
d��d�}WnHtk
�r}z(t|��	d�d�
�}t||||��W5d}~XYnXn:|dk�r(t|�}n&|dk�r<t|�}n|dk�rNt
|}t|||�VqdS)z�This is called with the stream as returned by `tokenize` and wraps
        every token in a :class:`Token` and converts the value.
        r%rr&r )r"r#r(�keywordrzInvalid character in identifierrrd����ascii�backslashreplacezunicode-escaper;Nrrr)�ignored_tokensr�r��check_ident�isidentifierr�encode�decode�	Exceptionre�strip�intr�	operatorsr�)	r|r�rr�rrbrarv�msgr?r?rCr�3sP�
��"




z
Lexer.wrapccs@t|�}|��}|jr<|r<dD]}|�|�r|�d�q<qd�|�}d}d}dg}	|dk	r�|dkr�|dksttd	��|	�|d
�nd}|j|	d}
t|�}g}|
D�]h\}
}}|
�	||�}|dkr�q�|r�|dkr�q�t
|t��r�t|�D]�\}}|j
tk�r
|||��q�|d
k�rdt|���D]4\}}|dk	�r |||fV||�d�7}�q��q td|
��q�|�|d�}|�s�|tk�r�|||fV||�d�7}q�n�|��}|dk�r>|dk�r�|�d�nv|dk�r�|�d�n`|dk�r�|�d�nJ|dk�r>|�std||||��|��}||k�r>td||f|||��|�sN|tk�rZ|||fV||�d�7}|��}|dk	�r�|dk�r�|	��nT|d
k�r�t|���D]$\}}|dk	�r�|	�|��q�q�td|
��n
|	�|�|j|	d}
n||k�rtd|
��|}q�q�||k�r dStd|||f|||��q�dS)z�This method tokenizes the text and returns the tokens in a
        generator.  Use this method if you just want to tokenize a template.
        )z
�
�
r�r�rrdr�N)rlrkz
invalid stateZ_beginr�)r!r r&r�z?%r wanted to resolve the token dynamically but no group matchedrr5r6r3r4r1r2)r6r4r2zunexpected '%s'zunexpected '%s', expected '%s'r�zC%r wanted to resolve the new state dynamically but no group matchedz,%r yielded empty string without stack changezunexpected char %r at %d)r�
splitlinesr��endswithrrr��AssertionErrorrwrKr��
isinstancer��	enumerate�	__class__ryr�	groupdict�count�RuntimeErrorr��ignore_if_emptyr�pop�end)r|r�rr�r��lines�newline�posr�stackZstatetokensZ
source_lengthZbalancing_stackZregex�tokensZ	new_stater��idxrbrOrar(Zexpected_opZpos2r?r?rCr�\s�



�


�




��
��






�

�

��zLexer.tokeniter)NNN)NN)NN)	r�r�r�r�r~r�r�r�r�r?r?r?rCr��s

)r�)kr�rFZcollections.abcr�collectionsrrZjinja2._compatrrrrZjinja2.exceptionsrZjinja2.utilsr	r�r��Ur�r�r�r��SyntaxErrorr�r�Zjinja2r�format�pattern�sys�modulesr�rhZ	TOKEN_ADDZTOKEN_ASSIGNZTOKEN_COLONZTOKEN_COMMAZ	TOKEN_DIVZ	TOKEN_DOTZTOKEN_EQZTOKEN_FLOORDIVZTOKEN_GTZ
TOKEN_GTEQZTOKEN_LBRACEZTOKEN_LBRACKETZTOKEN_LPARENZTOKEN_LTZ
TOKEN_LTEQZ	TOKEN_MODZ	TOKEN_MULZTOKEN_NEZ
TOKEN_PIPEZ	TOKEN_POWZTOKEN_RBRACEZTOKEN_RBRACKETZTOKEN_RPARENZTOKEN_SEMICOLONZ	TOKEN_SUBZTOKEN_TILDEr�r�r�r�r�r�rUrVrWrXr�r�rQrRrSrYrZr�r�rTr[r�r\r��dictrPrKr�r�rtr��	frozensetr�r�r_rcrgrjrx�objectryr�r�r�r�r�r�r?r?r?rC�<module>s�




����
+^

Zerion Mini Shell 1.0