|
Server : Apache System : Linux cvar2.toservers.com 3.10.0-962.3.2.lve1.5.73.el7.x86_64 #1 SMP Wed Aug 24 21:31:23 UTC 2022 x86_64 User : njnconst ( 1116) PHP Version : 8.4.18 Disable Function : NONE Directory : /lib/python2.7/site-packages/jinja2/ |
Upload File : |
�
-/�_c @ s� d 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 e d
� Z e j d e j � Z e j d � Z e j d e j � Z e j d � Z e j d e j e j B� Z y e d d d � Wn& e k
rNe j d � Z e Z n Xd d l m! Z e" 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% � Z0 e
d& � Z1 e
d' � Z2 e
d( � Z3 e
d) � Z4 e
d* � Z5 e
d+ � Z6 e
d, � Z7 e
d- � Z8 e
d. � Z9 e
d/ � Z: e
d0 � Z; e
d1 � Z< e
d2 � Z= e
d3 � Z> e
d4 � Z? e
d5 � Z@ e
d6 � ZA e
d7 � ZB e
d8 � ZC e
d9 � ZD e
d: � ZE e
d; � ZF e
d< � ZG e
d= � ZH e
d> � ZI e
d? � ZJ e
d@ � ZK e
dA � ZL e
dB � ZM e
dC � ZN e
dD � ZO e
dE � ZP e
dF � ZQ e
dG � ZR e
dH � ZS i e# dI 6e; dJ 6e' dK 6e* dL 6e3 dM 6e2 dN 6e6 dO 6e< dP 6e. dQ 6e8 dR 6e/ dS 6e9 dT 6e- dU 6e7 dV 6e) dW 6e4 dX 6e+ dY 6e, dZ 6e0 d[ 6e1 d\ 6e$ d] 6e( d^ 6e% d_ 6e5 d` 6e& da 6e: db 6ZT eU g e eT � D] \ ZV ZW eW eV f ^ q}� ZX eY eT � eY eX � k s�tZ dc � � e j dd d` j[ de � e\ eT df dg � �D� � � Z] e^ eI eK eJ e= eN eO eP g � Z_ e^ e= eQ eK eP g � Z` dh � Za di � Zb dj � Zc dk � Zd dl � Ze dm ef f dn � � YZg do eh f dp � � YZi e dq ef f dr � � Y� Zj e ds ef f dt � � Y� Zk du � Zl dv eh f dw � � YZm dx ef f dy � � YZn d S(z s� Implements a Jinja / Python combination lexer. The ``Lexer`` class
is used to do some preprocessing. It filters out invalid operators like
the bitshift operators we don't allow in templates. It separates
template code and python code in expressions.
i����N( t literal_eval( t deque( t
itemgetteri ( t implements_iterator( t intern( t iteritems( t text_type( t TemplateSyntaxError( t LRUCachei2 s \s+s (\r\n|\r|\n)s7 ('([^'\\]*(?:\\.[^'\\]*)*)'|"([^"\\]*(?:\\.[^"\\]*)*)")s
(\d+_)*\d+s�
(?<!\.) # doesn't start with a .
(\d+_)*\d+ # digits, possibly _ separated
(
(\.(\d+_)*\d+)? # optional fractional part
e[+\-]?(\d+_)*\d+ # exponent part
|
\.(\d+_)*\d+ # required fractional part
)
s föös <unknown>t evals [a-zA-Z_][a-zA-Z0-9_]*( t patternt addt assignt colont commat divt dott eqt floordivt gtt gteqt lbracet lbrackett lparent ltt lteqt modt mult net pipet powt rbracet rbrackett rparent semicolont subt tildet
whitespacet floatt integert namet stringt operatort block_begint block_endt variable_begint variable_endt raw_begint raw_endt
comment_begint comment_endt commentt linestatement_begint linestatement_endt linecomment_begint linecomment_endt linecommentt datat initialt eoft +t -t /s //t *t %s **t ~t [t ]t (t )t {t }s ==s !=t >s >=t <s <=t =t .t :t |t ,t ;s operators droppeds (%s)c c s | ] } t j | � Vq d S( N( t ret escape( t .0t x( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pys <genexpr>� s t keyc C s t | � S( N( t len( RS ( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyt <lambda>� s c C sx | t k r t | Si d t 6d t 6d t 6d t 6d t 6d t 6d t 6d t 6d t 6d t
6d
t 6d t 6j
| | � S( Ns begin of comments end of commentR3 s begin of statement blocks end of statement blocks begin of print statements end of print statements begin of line statements end of line statements template data / texts end of template( t reverse_operatorst TOKEN_COMMENT_BEGINt TOKEN_COMMENT_ENDt
TOKEN_COMMENTt TOKEN_LINECOMMENTt TOKEN_BLOCK_BEGINt TOKEN_BLOCK_ENDt TOKEN_VARIABLE_BEGINt TOKEN_VARIABLE_ENDt TOKEN_LINESTATEMENT_BEGINt TOKEN_LINESTATEMENT_ENDt
TOKEN_DATAt TOKEN_EOFt get( t
token_type( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyt _describe_token_type� s
c C s# | j t k r | j St | j � S( s# Returns a description of the token.( t typet
TOKEN_NAMEt valueRf ( t token( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyt describe_token� s c C sG d | k r7 | j d d � \ } } | t k r= | Sn | } t | � S( s0 Like `describe_token` but for token expressions.RL i ( t splitRh Rf ( t exprRg Ri ( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyt describe_token_expr� s c C s t t j | � � S( ss Count the number of newline characters in the string. This is
useful for extensions that filter a stream.
( RU t
newline_ret findall( Ri ( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyt count_newlines� s c C s t j } t | j � t | | j � f t | j � t | | j � f t | j � t | | j � f g } | j d k r� | j t | j � t d | | j � f � n | j
d k r� | j t | j
� t d | | j
� f � n g t | d t �D] } | d ^ q� S( sA Compiles all the rules from the environment into a list of rules.s ^[ \t\v]*s (?:^|(?<=\S))[^\S\r\n]*t reversei N( RP RQ RU t comment_start_stringRX t block_start_stringR\ t variable_start_stringR^ t line_statement_prefixt Nonet appendR` t line_comment_prefixt TOKEN_LINECOMMENT_BEGINt sortedt True( t environmentt et rulesRS ( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyt
compile_rules� s* t Failurec B s# e Z d Z e d � Z d � Z RS( sj Class that raises a `TemplateSyntaxError` if called.
Used by the `Lexer` to specify known errors.
c C s | | _ | | _ d S( N( t messaget error_class( t selfR� t cls( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyt __init__� s c C s | j | j | | � � d S( N( R� R� ( R� t linenot filename( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyt __call__� s ( t __name__t
__module__t __doc__R R� R� ( ( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyR� � s t Tokenc B s` e Z d Z d Z d � e d � D� \ Z Z Z d � Z d � Z d � Z
d � Z d � Z RS( s Token class.c c s! | ] } t t | � � Vq d S( N( t propertyR ( RR RS ( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pys <genexpr> s i c C s% t j | | t t | � � | f � S( N( t tuplet __new__R t str( R� R� Rg Ri ( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyR� s c C s7 | j t k r t | j S| j d k r0 | j S| j S( NR( ( Rg RW Ri ( R� ( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyt __str__ s
c C sE | j | k r t Sd | k rA | j d d � | j | j g k St S( s� 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.
RL i ( Rg R| Rl Ri t False( R� Rm ( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyt test s
"c G s( x! | D] } | j | � r t Sq Wt S( s( Test against multiple token expressions.( R� R| R� ( R� t iterableRm ( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyt test_any s
c C s d | j | j | j f S( Ns Token(%r, %r, %r)( R� Rg Ri ( R� ( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyt __repr__' s ( (
R� R� R� t __slots__t rangeR� Rg Ri R� R� R� R� R� ( ( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyR� s
t TokenStreamIteratorc B s) e Z d Z d � Z d � Z d � Z RS( s` The iterator for tokenstreams. Iterate over the stream
until the eof token is reached.
c C s
| | _ d S( N( t stream( R� R� ( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyR� 1 s c C s | S( N( ( R� ( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyt __iter__4 s c C sE | j j } | j t k r4 | j j � t � � n t | j � | S( N( R� t currentRg Rc t closet
StopIterationt next( R� Rj ( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyt __next__7 s
( R� R� R� R� R� R� ( ( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyR� + s t TokenStreamc B s� e Z d Z d � Z d � Z d � Z e Z e d � � Z d � Z d � Z
d d � Z d � Z d
� Z
d � Z d � Z d
� Z RS( s� 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`.
c C sY t | � | _ t � | _ | | _ | | _ t | _ t d t d � | _
t | � d S( Ni t ( t itert _iterR t _pushedR( R� R� t closedR� t
TOKEN_INITIALR� R� ( R� t generatorR( R� ( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyR� G s c C s
t | � S( N( R� ( R� ( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyR� P s c C s t | j � p | j j t k S( N( t boolR� R� Rg Rc ( R� ( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyt __bool__S s c C s | S( s Are we at the end of the stream?( ( R� ( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyt eosX s c C s | j j | � d S( s Push a token back to the stream.N( R� Rx ( R� Rj ( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyt push] s c C s/ t | � } | j } | j | � | | _ | S( s Look at the next token.( R� R� R� ( R� t old_tokent result( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyt looka s
i c C s% x t | � D] } t | � q
Wd S( s Got n tokens ahead.N( R� R� ( R� t nt _( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyt skipi s c C s | j j | � r t | � Sd S( sq Perform the token test and return the token if it matched.
Otherwise the return value is `None`.
N( R� R� R� ( R� Rm ( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyt next_ifn s c C s | j | � d k S( s8 Like :meth:`next_if` but only returns `True` or `False`.N( R� Rw ( R� Rm ( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyt skip_ifu s c C st | j } | j r' | j j � | _ nI | j j t k rp y t | j � | _ Wqp t k
rl | j � qp Xn | S( s| Go one token ahead and return the old one.
Use the built-in :func:`next` instead of calling this directly.
( R� R� t popleftRg Rc R� R� R� R� ( R� t rv( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyR� y s
c C s1 t | j j t d � | _ d | _ t | _ d S( s Close the stream.R� N( R� R� R� Rc Rw R� R| R� ( R� ( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyR� � s c C s� | j j | � s� t | � } | j j t k rX t d | | j j | j | j � � n t d | t | j � f | j j | j | j � � n z | j SWd t
| � Xd S( s} Expect a given token type and return it. This accepts the same
argument as :meth:`jinja2.lexer.Token.test`.
s( unexpected end of template, expected %r.s expected token %r, got %rN( R� R� Rn Rg Rc R R� R( R� Rk R� ( R� Rm ( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyt expect� s ( R� R� R� R� R� R� t __nonzero__R� R� R� R� R� R� R� R� R� R� ( ( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyR� @ s c C s� | j | j | j | j | j | j | j | j | j | j | j
| j f } t j
| � } | d k r� t | � } | t | <n | S( s( Return a lexer which is probably cached.N( Rt t block_end_stringRu t variable_end_stringRs t comment_end_stringRv Ry t trim_blockst
lstrip_blockst newline_sequencet keep_trailing_newlinet _lexer_cacheRd Rw t Lexer( R} RT t lexer( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyt get_lexer� s"
t OptionalLStripc B s e Z d Z d Z d � Z RS( sW A special tuple for marking a point in the state that can have
lstrip applied.
c O s t t | � j | | � S( N( t superR� R� ( R� t memberst kwargs( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyR� � s ( ( R� R� R� R� R� ( ( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyR� � s R� c B sP e Z d Z d � Z d � Z d d d d � Z d d d � Z d d d � Z RS( s
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.
c C s� t j } d � } t t d f t t d f t t d f t t
d f t t d f t
t d f g } t | � } | j r{ d p~ d } | j r� | d � n d | _ | j | _ | j | _ i | d d j d | | j � | | j � | | j � f g g | D] \ } } d | | f ^ q� � � t t d � d f | d
� t d f g d 6| d | | j � | | j � | f � t t f d
f | d � t d � f d f g t 6| d | | j � | | j � | f � t d
f g | t 6| d | | j! � | | j! � f � t" d
f g | t# 6| d | | j � | | j � | | j � | f � t t t$ � d
f | d � t d � f d f g t% 6| d � t& d
f g | t' 6| d � t( t) f d
f g t* 6| _+ d S( Nc S s t j | t j t j B� S( N( RP t compilet Mt S( RS ( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyt c� s s \n?R� s [^ \t]s (.*?)(?:%s)RM s0 (?P<raw_begin>%s(\-|\+|)\s*raw\s*(?:\-%s\s*|%s))s (?P<%s>%s(\-|\+|))s #bygroups .+t roots (.*?)((?:\-%s\s*|%s)%s)s #pops (.)s Missing end of comment tags (?:\-%s\s*|%s)%ss
\-%s\s*|%ss1 (.*?)((?:%s(\-|\+|))\s*endraw\s*(?:\-%s\s*|%s%s))s Missing end of raw directives \s*(\n|$)s (.*?)()(?=\n|$)(, RP RQ t
whitespace_ret TOKEN_WHITESPACERw t float_ret TOKEN_FLOATt
integer_ret
TOKEN_INTEGERt name_reRh t string_ret TOKEN_STRINGt operator_ret TOKEN_OPERATORR� R� R� t lstrip_unless_reR� R� t joinRt R� R� Rb R� RZ RY R� RX R] R\ R� R_ R^ t
TOKEN_RAW_ENDt TOKEN_RAW_BEGINRa R` R[ t TOKEN_LINECOMMENT_ENDRz R ( R� R} R~ R� t tag_rulest root_tag_rulest block_suffix_reR� t r( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyR� � s~ +
"
" c C s t j | j | � S( s@ Called for strings and template data to normalize it to unicode.( Ro R# R� ( R� Ri ( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyt _normalize_newlinesa s c C s7 | j | | | | � } t | j | | | � | | � S( s: Calls tokeniter + tokenize and wraps it in a token stream.( t tokeniterR� t wrap( R� t sourceR( R� t stateR� ( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyt tokenizee s c c s� x�| D]�\ } } } | t k r( q n�| t k r= t } n�| t k rR t } n�| t t f k rj q nh| t k r� | j | � } nJ| d k r� | } n5| t k r� t
| � } t r�| j � r�t
d | | | � � q�n� | t k rky/ | j | d d !� j d d � j d � } Wq�t k
rg} t
| � j d � d j � } t
| | | | � � q�Xng | t k r�t | j d d
� � } n@ | t k r�t | j d d
� � } n | t k r�t | } n t | | | � Vq Wd S( s� This is called with the stream as returned by `tokenize` and wraps
every token in a :class:`Token` and converts the value.
t keywords Invalid character in identifieri i����t asciit backslashreplaces unicode-escapeRL R� R� N( t ignored_tokensR` R\ Ra R] R� R� Rb R� Rh R� t check_identt isidentifierR R� t encodet decodet ExceptionRl t stripR� t intt replaceR� R R� t operatorsR� ( R� R� R( R� R� Rj Ri R~ t msg( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyR� j sB
c c s� t | � } | j � } | j r[ | r[ x1 d D]& } | j | � r. | j d � Pq. q. Wn d j | � } d } d } d g } | d k r� | d k r� | d! k s� t d
� � | j | d � n | j | d }
t | � } g } | j
}
d } t } x�x�|
D]q\ } } } | j | | � } | d k r8qn | rY| t
t t f k rYqn t | t � ry| j � } t | t � r{| d } t d
� | d d d � D� � } | d k r�| j � } | t | � j d � } | f | d } q{| d k r{|
d k r{| j � j t � r{| j d � d } | d k sH| rx|
j | | � su| | f | d } quqxq{n x t | � D]� \ } } | j t k r�| | | � � q�| d k r(x� t | j � � D]= \ } } | d k r�| | | f V| | j d � 7} Pq�q�Wt d | � � q�| | } | sD| t! k rU| | | f Vn | | j d � | 7} d } q�Wn| j" � } | t# k rS| d k r�| j d � qS| d k r�| j d � qS| d k r�| j d � qS| d" k rS| st$ d | | | | � � n | j% � } | | k rPt$ d | | f | | | � � qPqSn | se| t! k rv| | | f Vn | | j d � 7} | j" � d d k } | j& � } | d k rP| d k r�| j% � nl | d k r/x] t | j � � D]) \ } } | d k r�| j | � Pq�q�Wt d | � � n
| j | � | j | d }
n | | k rot d | � � n | } PqW| | k r�d St$ d | | | f | | | � � q� d S(# s� This method tokenizes the text and returns the tokens in a
generator. Use this method if you just want to tokenize a template.
s
s
s
R� i i R� t variablet blocks
invalid statet _begini����c s s! | ] } | d k r | Vq d S( N( Rw ( RR t g( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pys <genexpr>� s i NR= R< s #bygroups? %r wanted to resolve the token dynamically but no group matchedRF RG RD RE RB RC s unexpected '%s's unexpected '%s', expected '%s's #popsC %r wanted to resolve the new state dynamically but no group matcheds, %r yielded empty string without stack changes unexpected char %r at %d( s
s
s
( s variables block( RG RE RC (' R t
splitlinesR� t endswithRx R� Rw t AssertionErrorR RU R� R| t matchR_ R] Ra t
isinstanceR� t groupsR� R� t rstript countt groupdictRd R^ t rfindt searcht enumeratet __class__R� R t RuntimeErrort ignore_if_emptyt groupR� R t popt end( R� R� R( R� R� t linest newlinet posR� t stackt statetokenst
source_lengtht balancing_stackR� t newlines_strippedt
line_startingt regext tokenst new_statet mR� t textt
strip_signt strippedt l_post idxRj RT Ri R9 t expected_opt pos2( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyR� � s�
# !
N( R� R� R� R� R� Rw R� R� R� ( ( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyR� � s � ,(o R� RP t astR t collectionsR R* R t _compatR R R R t
exceptionsR t utilsR R� R� t UR� Ro R� R� R� t
IGNORECASEt VERBOSER� t SyntaxErrorR� R� R� t _identifierR
R| t TOKEN_ADDt TOKEN_ASSIGNt TOKEN_COLONt TOKEN_COMMAt TOKEN_DIVt TOKEN_DOTt TOKEN_EQt TOKEN_FLOORDIVt TOKEN_GTt
TOKEN_GTEQt TOKEN_LBRACEt TOKEN_LBRACKETt TOKEN_LPARENt TOKEN_LTt
TOKEN_LTEQt TOKEN_MODt TOKEN_MULt TOKEN_NEt
TOKEN_PIPEt TOKEN_POWt TOKEN_RBRACEt TOKEN_RBRACKETt TOKEN_RPARENt TOKEN_SEMICOLONt TOKEN_SUBt TOKEN_TILDER� R� R� Rh R� R� R\ R] R^ R_ R� R� RX RY RZ R` Ra Rz R� R[ Rb R� Rc R� t dictt kt vRW RU R� R� R{ R� t frozensetR� R Rf Rk Rn Rq R� t objectR� R� R� R� R� R� R� R� ( ( ( s. /tmp/pip-install-sTXtzD/Jinja2/jinja2/lexer.pyt <module> s
1$/ )
(f