/usr/lib/python3/dist-packages/jinja2/__pycache__
Edit: /usr/lib/python3/dist-packages/jinja2/__pycache__/lexer.cpython-310.pyc (20524B)
o
g-u @ sp U d Z ddlZddlZddlmZ zddlmZ W n ey( ddl mZ Y nw ddl
m Z ddl m
Z ddlmZ dd lmZ ejrNddlZdd
lmZ ed Zejejd f ed
< e dZ e dZ e dej Z e dej!ej"B Z#e dej!ej"B Z$e dZ%e dZ&e dZ'e dZ(e dZ)e dZ*e dZ+e dZ,e dZ-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 d)Z;e d*Z
e d-Z?e d.Z@e d/ZAe d0ZBe d1ZCe d2ZDe d3ZEe d4ZFe d5ZGe d6ZHe d7ZIe d8ZJe d9ZKe d:ZLe d;ZMe d<ZNe d=ZOe d>ZPe d?ZQe d@ZRe dAZSe dBZTe dCZUi dDe%dEe=dFe)dGe,dHe5dIe4dJe8dKe>dLe0dMe:dNe1dOe;dPe/dQe9dRe+dSe6dTe-e.e2e3e&e*e'e7e(e) z>= s rW zoperators droppedrO c c s | ]}t |V qd S N)reescaperS xrR rR rV r] c C s
t | S rX )lenr\ rR rR rV s
ra )key
token_typereturnc C sL | t v rt | S tdtdtdtdtdtdtdtdt dt
d t d
t d i
| | S ) Nzbegin of commentzend of commentr5 zbegin of statement blockzend of statement blockzbegin of print statementzend of print statementzbegin of line statementzend of line statementztemplate data / textzend of template)reverse_operatorsTOKEN_COMMENT_BEGINTOKEN_COMMENT_END
TOKEN_COMMENTTOKEN_LINECOMMENTTOKEN_BLOCK_BEGINTOKEN_BLOCK_ENDTOKEN_VARIABLE_BEGINTOKEN_VARIABLE_ENDTOKEN_LINESTATEMENT_BEGINTOKEN_LINESTATEMENT_END
TOKEN_DATA TOKEN_EOFget)rc rR rR rV _describe_token_type s"
rs tokenTokenc C s | j tkr| jS t| j S )z#Returns a description of the token.)type
TOKEN_NAMEvaluers )rt rR rR rV describe_token s
ry exprc C s8 d| v r| dd\}}|tkr|S t|S | }t|S )z0Like `describe_token` but for token expressions.rN r )splitrw rs )rz rv rx rR rR rV describe_token_expr s r| rx c C s t t| S )zsCount the number of newline characters in the string. This is
useful for extensions that filter a stream.
)r_
newline_refindall)rx rR rR rV count_newlines r environmentr c C s t j}t| jt|| jft| jt|| jft| jt|| jfg}| j dur8|
t| j t d|| j f | j durM|
t| j t
d|| j f dd t|ddD S )zACompiles all the rules from the environment into a list of rules.Nz ^[ \t\v]*z(?:^|(?<=\S))[^\S\r\n]*c S s g | ]}|d d qS )r NrR r[ rR rR rV
s z!compile_rules..T)reverse)rY rZ r_ comment_start_stringrf block_start_stringrj variable_start_stringrl line_statement_prefixappendrn line_comment_prefixTOKEN_LINECOMMENT_BEGINsorted)r erulesrR rR rV
compile_rules s:
r c @ sF e Zd ZdZefdedeje ddfddZde d edd
fd d Z
dS )
FailurezjClass that raises a `TemplateSyntaxError` if called.
Used by the `Lexer` to specify known errors.
messageclsrd Nc C s || _ || _d S rX )r error_class)selfr r rR rR rV __init__ s
zFailure.__init__linenofilenamez te.NoReturnc C s | | j||rX )r r )r r r rR rR rV __call__
s zFailure.__call__) __name__
__module__ __qualname____doc__r strtTyper intr rR rR rR rV r s
r c @ sX e Zd ZU eed< eed< eed< defddZdedefdd Zd
edefd d Z d
S )ru r rv rx rd c C t | S rX )ry r rR rR rV __str__ z
Token.__str__rz c C s2 | j |krdS d|v r|dd| j | jgkS dS )zTest 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.
TrN r F)rv r{ rx r rz rR rR rV test s
z
Token.testiterablec s t fdd|D S )z(Test against multiple token expressions.c 3 s | ]} |V qd S rX )r )rS rz r rR rV r] ' r^ z!Token.test_any..)any)r r rR r rV test_any% s zToken.test_anyN)
r r r r __annotations__r r boolr r rR rR rR rV ru s
c @ s2 e Zd ZdZd ddZd
dd Zdefd
d ZdS )TokenStreamIteratorz`The iterator for tokenstreams. Iterate over the stream
until the eof token is reached.
stream TokenStreamrd Nc C s
|| _ d S rX )r )r r rR rR rV r / s
z TokenStreamIterator.__init__c C s | S rX rR r rR rR rV __iter__2 s z TokenStreamIterator.__iter__c C s. | j j}|jtu r| j tt| j |S rX )r currentrv rq close
StopIterationnextr rt rR rR rV __next__5 s
z TokenStreamIterator.__next__)r r rd N)rd r )r r r r r r ru r rR rR rR rV r * s
r c @ s e Zd ZdZdeje deje deje fddZ de
fdd Z de fd
d Z
ede fd d
ZdeddfddZdefddZd#deddfddZdedeje fddZdede fdd Zdefd d Zd$d d Zdedefd!d"ZdS )%r zA 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`.
generatorr* r c C s> t || _t | _|| _|| _d| _tdtd| _ t
| d S )NFr ) iter_iterr _pushedr* r closedru
TOKEN_INITIALr r )r r r* r rR rR rV r F s
zTokenStream.__init__rd c C r rX )r r rR rR rV r T r zTokenStream.__iter__c C s t | jp
| jjtuS rX )r r r rv rq r rR rR rV __bool__W s zTokenStream.__bool__c C s | S )z Are we at the end of the stream?rR r rR rR rV eosZ s zTokenStream.eosrt Nc C s | j | dS )z Push a token back to the stream.N)r r r rR rR rV push_ s zTokenStream.pushc C s" t | }| j}| | || _|S )zLook at the next token.)r r r )r old_tokenresultrR rR rV lookc s
zTokenStream.lookr nc C s t |D ]}t| qdS )zGot n tokens ahead.N)ranger )r r _rR rR rV skipk s
zTokenStream.skiprz c C s | j |r
t| S dS )zqPerform the token test and return the token if it matched.
Otherwise the return value is `None`.
N)r r r r rR rR rV next_ifp s zTokenStream.next_ifc C s | |duS )z8Like :meth:`next_if` but only returns `True` or `False`.N)r r rR rR rV skip_ify s zTokenStream.skip_ifc C s\ | j }| jr| j | _ |S | j jtur,z t| j| _ W |S ty+ | Y |S w |S )z|Go one token ahead and return the old one.
Use the built-in :func:`next` instead of calling this directly.
) r r popleftrv rq r r r r )r rvrR rR rV r } s
zTokenStream.__next__c C s& t | jjtd| _td| _d| _dS )zClose the stream.r rR TN)ru r r rq r r r r rR rR rV r s
zTokenStream.closec C sn | j |s3t|}| j jtu r td|d| j j| j| jtd|dt | j | j j| j| jt
| S )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 rM zexpected token z, got ) r r r| rv rq r r r* r ry r r rR rR rV expect s
zTokenStream.expect)r )rd N)r r r r r Iterableru Optionalr r r r r r propertyr r r r r r r r r r rR rR rR rV r @ s*
r c C sZ | j | j| j| j| j| j| j| j| j| j | j
| j f }t
|}|du r+t| t |< }|S )z(Return a lexer which is probably cached.N)r block_end_stringr variable_end_stringr comment_end_stringr r trim_blocks
lstrip_blocksnewline_sequencekeep_trailing_newliner rr r )r rb lexerrR rR rV get_lexer s"
r c s$ e Zd ZdZdZ fddZ ZS )OptionalLStripzWA special tuple for marking a point in the state that can have
lstrip applied.
rR c s t | |S rX )super__new__)r memberskwargs __class__rR rV r s zOptionalLStrip.__new__)r r r r __slots__r
__classcell__rR rR r rV r s r c @ sN e Zd ZU eje ed< ejeejedf eje f ed< ej
e ed< dS )_Ruler .tokenscommandN) r r r r Patternr r UnionTupler r rR rR rR rV r s
$r c @ s e Zd ZdZdddZdedefd d
Z dd ed eje d
eje deje de f
ddZ
ddej ej e
eef d eje d
eje deje fddZ dd ed eje d
eje deje dejej e
eef f
ddZdS )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.
r r rd Nc
C s2 t j}dtdtjt fdd}tttd ttt d tt
t d tt t
d tttd tttd g}t|}||j}||j}||j}||j} |jrLdnd}
|jrU|dnd | _|j| _|j| _d| d | d
| d } d | gd
d |D } dt|d| dt t ddt|dt d gt t|d| d| d
| |
d t t!fdt|dt"dfd gt#t|d| d| d
| |
dt$dg| t%t|d| d
| t&dg| t't|d| d | d| d
| |
d
t t t(dt|dt"d fd gt)t|d t*dg| t+t|d t,t-fdgi| _.d S ) Nr\ rd c S s t | t jt jB S rX )rY compileMSr` rR rR rV c s zLexer.__init__..cz\n?r z[^ \t]z(?Pz(\-|\+|)\s*raw\s*(?:\-z\s*|z))rO c S s" g | ]
\}}d | d| dqS )z(?P.rootz(.*?)(?:rG #bygroupz.+z (.*?)((?:\+z|\-#popz(.)zMissing end of comment tagz(?:\+z\-z (.*?)((?:z(\-|\+|))\s*endraw\s*(?:\+z Missing end of raw directivez \s*(\n|$)z(.*?)()(?=\n|$))/rY rZ r r r r
whitespace_reTOKEN_WHITESPACEfloat_re TOKEN_FLOAT
integer_re
TOKEN_INTEGERname_rerw string_re TOKEN_STRING operator_reTOKEN_OPERATORr r r r r r r lstrip_unless_rer r joinr rp rf rh rg r rj rk rl rm TOKEN_RAW_BEGIN
TOKEN_RAW_ENDrn ro r ri TOKEN_LINECOMMENT_ENDr )
r r r r tag_rulesroot_tag_rulesblock_start_re block_end_recomment_end_revariable_end_reblock_suffix_re root_raw_re
root_parts_rerR rR rV r s
zLexer.__init__rx c C s t | j|S )z`Replace all newlines with the configured sequence in strings
and template data.
)r} r% r )r rx rR rR rV _normalize_newlinesY r zLexer._normalize_newlinessourcer* r statec C s& | ||||}t| |||||S )z:Calls tokeniter + tokenize and wraps it in a token stream.) tokeniterr wrap)r r r* r r r rR rR rV tokenize_ s zLexer.tokenizer c
c sT |D ]\}}}|t v r
q|}|tkrt}n|tkr t}n|ttfv r$q|tkr.| |}nr|dkr5|}nk|t krG|}|
sFt d|||nY|t kr}z| |dd
ddd}W nB ty| } zt|dd } t | ||||d }~ww |tkrt|d
d d }n|tkrt|d
d }n|tkrt| }t|||V qd S )
zThis is called with the stream as returned by `tokenize` and wraps
every token in a :class:`Token` and converts the value.
keywordz Invalid character in identifierr asciibackslashreplacezunicode-escaperN Nr r r )ignored_tokensrn rj ro rk r r rp r rw isidentifierr r encodedecode Exceptionr r{ stripr r replacer r r operatorsru )
r r r* r r rt value_strrx r msgrR rR rV r j sR z
Lexer.wrapc c s* t |ddd }| js|d dkr|d= d|}d}d}dg}|dur:|dkr:|d v s3J d
||d | j|d } t|}
g } | j} d}
d } | D ]\}}}|||}|du rbqQ| rl|t t
t fv rlqQt |t
r6| }t |tr|d }td
d |ddd D }|dkr| }|t|d d}
|g|dd }n/|dkr| dur| ts|dd }|dks|r| ||s|d| g|dd }t|D ]W\}}|jtu r||||dkr| D ]\}}|dur|||fV ||d7 } nqt |dq|| } | s#|t vr)||| fV || d|
7 }d}
qni| } |t kr| dkrJ| d n@| dkrU| d n5| dkr`| d n*| dv r| sst d| d|||| ! } | | krt d| d | d|||| s|t vr||| fV || d7 }| dd dk}|" } |dur|d kr|! n*|dkr| D ]\}}|dur|| n qt |d n|| | j|d } n | |krt |d | } n||
krdS t d || d!| |||qO)"a This method tokenizes the text and returns the tokens in a
generator. Use this method if you just want to tokenize a template.
.. versionchanged:: 3.0
Only ``\n``, ``\r\n`` and ``\r`` are treated as line
breaks.
N r r
r r r )variableblockz
invalid state_beginTc s s | ] }|d ur|V qd S rX rR )rS grR rR rV r] s z"Lexer.tokeniter..r? r> r z= wanted to resolve the token dynamically but no group matchedrH rI rF rG rD rE )rI rG rE z unexpected ''z
', expected 'r zA wanted to resolve the new state dynamically but no group matchedz* yielded empty string without stack changezunexpected char z at )#r} r{ r r r r r_ r matchrm rk ro
isinstancetuplegroupsr r rstripcount groupdictrr rl rfindsearch enumerater r items RuntimeErrorignore_if_emptygroupr r popend) r r r* r r linesposr stack statetokens
source_lengthbalancing_stackr newlines_stripped
line_startingregexr new_statemr% text
strip_signstrippedl_posidxrt rb rx r; expected_oppos2rR rR rV r
s
zLexer.tokeniter)r r rd N)NNN)NN)r r r r r r r r r r r r r r Iteratorru r r
rR rR rR rV r sT
y
:)r r rd r )rr rY typingr astr collections.abcr ImportError collectionssysr _identifierr r
exceptionsr utilsr
TYPE_CHECKINGtyping_extensionster r r MutableMappingr r r r r} r r
IGNORECASEVERBOSEr r TOKEN_ADD TOKEN_ASSIGN TOKEN_COLON TOKEN_COMMA TOKEN_DIV TOKEN_DOTTOKEN_EQTOKEN_FLOORDIVTOKEN_GT
TOKEN_GTEQ TOKEN_LBRACETOKEN_LBRACKET TOKEN_LPARENTOKEN_LT
TOKEN_LTEQ TOKEN_MOD TOKEN_MULTOKEN_NE
TOKEN_PIPE TOKEN_POW TOKEN_RBRACETOKEN_RBRACKET TOKEN_RPARENTOKEN_SEMICOLON TOKEN_SUB TOKEN_TILDEr r r rw r r rj rk rl rm r r rf rg rh rn ro r r ri rp r rq r r, re r_ r r r frozensetr r. r rs ry r| r r Listr r
NamedTupleru r r r r$ r r r rR rR rR rV s6
&
")
m