U
|
Þ=®d« ã @ s U d Z ddlZddlZddlmZ ddlmZ ddlmZ ddlm Z ddlm
|
Z
|
ej rlddl Z dd lmZ e d
|
ejej¡Ze d ejej¡Zed d ddddddddddg Zeddddd d gZejejej ej ej ej d Z ej!e"ej#ej$ f e%d < G d d! d!Z&dS )"z8Parse tokens from the lexer into nodes for the compiler.é Né )Únodes)ÚTemplateAssertionError)ÚTemplateSyntaxError)Údescribe_token)Údescribe_token_expr)Ú EnvironmentÚ_ImportIncludeÚ
|
_MacroCallÚforÚifÚblockZextendsÚprintÚmacroÚincludeÚfromÚimportÚsetÚwithÚ
|
autoescapeÚeqÚneÚltZlteqÚgtZgteq)ÚaddÚsubÚmulÚdivÚfloordivÚmodÚ _math_nodesc
|
@ s
|
e Zd ZdZddeeje eje eje ddddZdefeeje ej
|
e ddd d
|
Z eje ej ej ed f eje dd d dZdeeje ddddZd
ejej ed f eje ddddZdejej ed f edddZdeje ejdddZejejej ej f dd d Zdej ed f eej ej d d d!Zejejejf dd"d#Z ej dd$d%Z ej dd&d'Z ej!dd(d)Z"ej#dd*d+Z$ej%dd,d-Z&ej'dd.d/Z(e)ee)d0d1d2Z*ej+dd3d4Z,ej-dd5d6Z.ej/dd7d8Z0e1dd9d:d;Z2ej3dd<d=Z4ej5dd>d?Z6ej7dd@dAZ8ej9ddBdCZ:e;j<dedDej=dEdFdGZ>e;j<deeejej ed f eejej?ej=ej f dIdJdGZ>deeejej ed f eejej?ej=ej f dIdKdGZ>deej@dLdMdNZAej@ddOdPZBej@ddQdRZCej@ddSdTZDej@ddUdVZEej@ddWdXZFej@ddYdZZGej@dd[d\ZHej@dd]d^ZIej@dd_d`ZJdeej@dadbdcZKej@ddddeZLdeeejej ed f eejej ej@f dfdgdhZMej ddidjZNejOddkdlZPej@ej@d9dmdnZQej@ej@d9dodpZRej@ejejSejTf d9dqdrZUej@ddsdtZVej ddudvZWej@ejXd9dwdxZYdejej@ eejej@ dydzd{ZZej@ej@d9d|d}Z[dejej ed f ej ej d~ddZ\ej]dddZ^dS )ÚParserz
This is the central parsing class Jinja uses. It's passed to
|
extensions and can be used to parse expressions or statements.
|
Nr )Ú environmentÚsourceÚnameÚfilenameÚstateÚreturnc C sl || _ | ||||¡| _|| _|| _d| _i | _| ¡ D ] }|jD ]}|j | j|< qBq8d| _
|
g | _ g | _ d S )NFr ) r" Ú _tokenizeÚstreamr$ r% ÚclosedÚ
|
extensionsZiter_extensionsÚtagsÚparseÚ_last_identifierÚ
|
_tag_stackÚ_end_token_stack)Úselfr" r# r$ r% r& Ú extensionÚtag© r4 úDd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\jinja2/parser.pyÚ__init__3 s þ
|
zParser.__init__z te.NoReturn)ÚmsgÚlinenoÚexcr' c C s( |dkr| j jj}|||| j| jdS )z Convenience method that raises `exc` with the message, passed
|
line number or last line number as well as the current name and
|
filename.
|
N)r) Úcurrentr8 r$ r% )r1 r7 r8 r9 r4 r4 r5 ÚfailJ s
|
|
z Parser.fail.)r$ Úend_token_stackr8 r' c C sÐ t }|D ]}| tt|¡ q
|
|r@d tttt|d ¡}nd }|d krTdg}nd|dg}|r|d k r||kr| d| d¡ n| d| d¡ | jrº| d| jd d¡ | d |¡|¡ d S )
|
Nz or éÿÿÿÿzUnexpected end of template.zEncountered unknown tag Ú.z\You probably made a nesting mistake. Jinja is expecting this tag, but currently looking for z*Jinja was looking for the following tags: z/The innermost block that needs to be closed is ú ) r ÚupdateÚmapr ÚjoinÚreprÚappendr/ r; )r1 r$ r< r8 ÚexpectedÚexprsZcurrently_lookingÚmessager4 r4 r5 Ú _fail_ut_eofX s0 ÿ
|
ÿ
|
ÿÿzParser._fail_ut_eof)r$ r8 r' c C s | || j|¡ dS )z¤Called if the parser encounters an unknown tag. Tries to fail
|
with a human readable error message that could help to identify
|
the problem.
|
N)rH r0 )r1 r$ r8 r4 r4 r5 Úfail_unknown_tag s zParser.fail_unknown_tag)Ú
|
end_tokensr8 r' c C s. t | j}|dk r | |¡ | d||¡ dS )z9Like fail_unknown_tag but for end of template situations.N)Úlistr0 rD rH )r1 rJ r8 Ústackr4 r4 r5 Úfail_eof s
|
|
zParser.fail_eof)Úextra_end_rulesr' c C s, | j jjdkrdS |dk r(| j j |¡S dS )z Are we at the end of a tuple?)Ú variable_endÚ block_endÚrparenTNF)r) r: ÚtypeÚtest_any)r1 rN r4 r4 r5 Ú is_tuple_end s
|
zParser.is_tuple_end)r8 r' c C s8 | j d7 _ t tj¡}tjj|d| j |d |S )zDReturn a new free identifier as :class:`~jinja2.nodes.InternalName`.r Úfi©r8 )r. ÚobjectÚ__new__r Ú InternalNameÚNoder6 )r1 r8 Úrvr4 r4 r5 Úfree_identifier s zParser.free_identifier©r' c C sâ | j j}|jdkr | d|j¡ | j |j¡ d}z|jt kr^t
|
| d| j jj }| W ¢rS |jdkrt| ¡ W ¢\S |jdkr| ¡ W ¢FS | j |j¡}|dk r¬|| W ¢$S | j ¡ d}| |j|j¡ W 5 |rÜ| j ¡ X dS ) zParse a single statement.r$ ztag name expectedTZparse_ÚcallÚfilterNF)r) r: rR r; r8 r/ rD ÚvalueÚpopÚ_statement_keywordsÚgetattrÚparse_call_blockÚparse_filter_blockr+ ÚgetrI )r1 ÚtokenZpop_tagÚfÚextr4 r4 r5 Úparse_statement¥ s*
|
|
|
|
|
|
zParser.parse_statementF)rJ Ú drop_needler' c C sL | j d¡ | j d¡ | |¡}| j jjdkr:| |¡ |rHt| j |S )aR Parse multiple statements into a list until one of the end tokens
|
is reached. This is used to parse the body of statements as it also
|
parses template data if appropriate. The parser checks first if the
|
current token is a colon and skips it if there is one. Then it checks
|
for the block end and parses until if one of the `end_tokens` is
|
reached. Per default the active token in the stream at the end of
|
the call is the matched end token. If this is not wanted `drop_needle`
|
can be set to `True` and the end token is removed.
|
ÚcolonrP Úeof)r) Úskip_ifÚexpectÚsubparser: rR rM Únext)r1 rJ rk Úresultr4 r4 r5 Úparse_statements s
|
|
|
zParser.parse_statementsc C sf t | jj}| jdd}| j d¡r<| ¡ }tj|||dS | d¡}| j ddd}tj
|
||||dS )zParse an assign statement.T)Úwith_namespaceÚassignrV N)z name:endset©rk ) rq r) r8 Úparse_assign_targetrn Ú parse_tupler ÚAssignÚ parse_filterrs Ú AssignBlock)r1 r8 ÚtargetÚexprZ filter_nodeÚbodyr4 r4 r5 Ú parse_setß s
|
zParser.parse_setc C s | j d¡j}| jdd}| j d¡ | jddd}d}| j d ¡rL| ¡ }| j d
|
¡}| d ¡}t| j j d krxg }n| jd dd}t
|
j |||||||dS )zParse a for loop.zname:for)úname:in)rN r F)úname:recursive)Ú with_condexprrN Núname:ifr )ú name:endforú name:elseZendfor)r Trv rV ) r) ro r8 rw rx rn Úparse_expressionrs rq r` r ÚFor)r1 r8 r| ÚiterÚtestÚ recursiver~ Úelse_r4 r4 r5 Ú parse_forê s ÿ
|
zParser.parse_forc C s t j| j d¡jd }}| jdd|_| d¡|_g |_ g |_
|
t | j}| d¡rvt j| jj jd}|j |¡ qq| d¡r| jdd d
|
|_
|
qq|S ) zParse an if construct.r rV F©r )ú name:elifr
ú
|
name:endifr r
)r Trv )r ÚIfr) ro r8 rx r rs r~ Zelif_r rq r: rD )r1 Únoderr rg r4 r4 r5 Úparse_ifý s
|
|
|
zParser.parse_ifc C s t jt| jjd}g }g }| jjjdkrr|r:| j d¡ | ¡ }| d¡ |
|
|¡ | j d¡ |
|
| ¡ ¡ q ||_ ||_ | jddd|_|S ) NrV rP ÚcommaÚparamru )z name:endwithTrv )r ÚWithrq r) r8 r: rR ro rw Úset_ctxrD r ÚtargetsÚvaluesrs r~ )r1 r r r r| r4 r4 r5 Ú
|
parse_with s
|
|
zParser.parse_withc C sD t jt| jjd}t d| ¡ ¡g|_| jddd|_ t
|
|g¡S )NrV r )zname:endautoescapeTrv ) r ZScopedEvalContextModifierrq r) r8 ÚKeywordr Úoptionsrs r~ ÚScope©r1 r r4 r4 r5 Úparse_autoescape s zParser.parse_autoescapec C s¢ t jt| jjd}| j d¡j|_| j d¡|_ | j d¡|_
|
| jj j dkrX| d¡ | jddd |_|j
|
rtd
|
d |jD s| d ¡ | j d |j ¡ |S )NrV r$ z name:scopedz name:requiredr zpBlock names in Jinja have to be valid Python identifiers and may not contain hyphens, use an underscore instead.)z name:endblockTrv c s s0 | ](}|j D ] }t|t jo$|j ¡ V q qd S ©N)r Ú
|
isinstanceÚ TemplateDataÚdataÚisspace)Ú.0r~ Úchildr4 r4 r5 Ú <genexpr>: s þz%Parser.parse_block.<locals>.<genexpr>z7Required blocks can only contain comments or whitespacezname:)r ÚBlockrq r) r8 ro r` r$ rn ÚscopedÚrequiredr: rR r; rs r~ Úallr r4 r4 r5 Ú parse_block& s ÿþ
|
zParser.parse_blockc C s" t jt| jjd}| ¡ |_|S ©NrV )r ÚExtendsrq r) r8 r Útemplater r4 r4 r5 Ú parse_extendsD s
|
zParser.parse_extends)r Údefaultr' c C sH | j j dd¡r>| j ¡ d¡r>t| j jdk|_| j ¡ n||_|S )Nz name:withz name:withoutú name:contextr ) r) r: rS Úlookr rq r` Ú with_contextÚskip)r1 r r° r4 r4 r5 Úparse_import_contextI s ÿþ zParser.parse_import_contextc C sb t jt| jjd}| ¡ |_| jj d¡rP| j ¡ d¡rPd|_
|
| j d¡ nd|_
|
| |d¡S )NrV z name:ignorez name:missingTé F) r ÚIncluderq r) r8 r r® r: r r² Zignore_missingr´ rµ r r4 r4 r5 Ú parse_includeU s
|
ÿzParser.parse_includec C sF t jt| jjd}| ¡ |_| j d¡ | jddj |_
|
| |d¡S )NrV úname:asT©Ú name_onlyF) r ÚImportrq r) r8 r r® ro rw r$ r| rµ r r4 r4 r5 Ú parse_importa s
|
|
zParser.parse_importc s t jtjjd ¡ _j d¡ g _t d fdd } jrVj d¡ jj
|
j dkrê| rlqøj dd }|j d
|
¡rjd |jtd j d ¡rÄj dd } j |j |j f¡ n j |j ¡ | søjj
|
j dkröqøqDj d¡ qDt ds
|
d _ S )NrV z name:importr] c sB j jjdkr>j ¡ d¡r>tj jdk _j ¡ dS dS )N> Úwithoutr r± r TF)r) r: r` r² r rq r³ r´ r4 ©r r1 r4 r5 Ú parse_contextn s ý
|
z(Parser.parse_from.<locals>.parse_contextr r$ Trº Ú_z4names starting with an underline can not be imported)r9 r¹ r³ F)r Ú
|
FromImportrq r) r8 r r® ro ÚnamesÚboolr: rR rw r$ Ú
|
startswithr; r rn rD Úhasattrr³ )r1 rÀ r| Úaliasr4 r¿ r5 Ú
|
parse_fromh s6
|
ý zParser.parse_from)r r' c C s g }|_ g }|_| j d¡ | jjjdkr|r>| j d¡ | jdd}| d¡ | j d¡rp| |
|
¡ ¡ n|r~| d¡ | |¡ q | j d¡ d S ) NÚlparenrQ r Trº r ru z-non-default argument follows default argument) ÚargsÚdefaultsr) ro r: rR rw r rn rD r r; )r1 r rÊ rË Úargr4 r4 r5 Úparse_signature s
|
|
|
|
zParser.parse_signaturec C sv t jt| jjd}| jjjdkr.| |¡ n g |_g |_ |
|
¡ }t |t j s\| d|j¡ ||_| jddd|_|S )NrV rÉ z expected call)z name:endcallTrv )r Ú CallBlockrq r) r8 r: rR rÍ rÊ rË r r ÚCallr; r^ rs r~ )r1 r Z call_noder4 r4 r5 rd ¢ s zParser.parse_call_blockc C s8 t jt| jjd}| jd dd|_| jddd|_|S )NrV T)Ú start_inline)zname:endfilterrv ) r Ú FilterBlockrq r) r8 rz r_ rs r~ r r4 r4 r5 re ± s zParser.parse_filter_blockc C sB t jt| jjd}| jddj|_| |¡ | jddd|_ |S )NrV Trº )z name:endmacrorv )
|
r ÚMacrorq r) r8 rw r$ rÍ rs r~ r r4 r4 r5 Ú parse_macro· s
|
|
zParser.parse_macroc C sP t jt| jjd}g |_ | jjjdkrL|j r:| j d¡ |j | ¡ ¡ q|S )NrV rP r )
|
r ÚOutputrq r) r8 r: rR ro rD r r r4 r4 r5 Ú parse_print¾ s zParser.parse_printzte.Literal[True])Ú
|
with_tupler» r' c C s d S r r4 )r1 rÖ r» r4 r4 r5 rw Ç s zParser.parse_assign_targetT)rÖ r» rN rt r' c C s d S r r4 )r1 rÖ r» rN rt r4 r4 r5 rw Í s c C sÄ |rN| j ¡ jdkrN| j d¡}t| j | j d¡}tj|j|j|jd}nL|rt| j d¡}tj |jd|jd}n&|r| j
|
d|d}n| ¡ }| d¡ | ¡ sÀ| dt|j ¡ |j¡ |S )a Parse an assignment target. As Jinja allows assignments to
|
tuples, this function can parse all allowed assignment targets. Per
|
default assignments to tuples are parsed, that can be disable however
|
by setting `with_tuple` to `False`. If only assignments to names are
|
wanted `name_only` can be set to `True`. The `extra_end_rules`
|
parameter is forwarded to the tuple parsing function. If
|
`with_namespace` is enabled, a namespace assignment may be parsed.
|
Údotr$ rV ÚstoreT)Ú
|
simplifiedrN zcan't assign to )r) r² rR ro rq r ÚNSRefr` r8 ÚNamerx Ú parse_primaryr Z
|
can_assignr; Ú__name__Úlower)r1 rÖ r» rN rt rg Úattrr| r4 r4 r5 rw × s*
|
ÿ
|
ÿ)r r' c C s |r | ¡ S | ¡ S )zºParse an expression. Per default all expressions are parsed, if
|
the optional `with_condexpr` parameter is set to `False` conditional
|
expressions are not parsed.
|
)Úparse_condexprÚparse_or)r1 r r4 r4 r5 r s zParser.parse_expressionc C sb | j jj}| ¡ }| j d¡r^| ¡ }| j d¡r<| ¡ }nd }tj||||d}| j jj}q|S )Nr r
rV )r) r: r8 rá rn rà r ZCondExpr)r1 r8 Úexpr1Zexpr2Zexpr3r4 r4 r5 rà
|
s
|
|
zParser.parse_condexprc C sF | j jj}| ¡ }| j d¡rB| ¡ }tj|||d}| j jj}q|S )Núname:orrV )r) r: r8 Ú parse_andrn r ÚOr©r1 r8 ÚleftÚrightr4 r4 r5 rá s
|
zParser.parse_orc C sF | j jj}| ¡ }| j d¡rB| ¡ }tj|||d}| j jj}q|S )Núname:andrV )r) r: r8 Ú parse_notrn r ÚAndræ r4 r4 r5 rä " s
|
zParser.parse_andc C s4 | j j d¡r,t| j j}tj| ¡ |dS | ¡ S )Núname:notrV ) r) r: r rq r8 r ÚNotrê Ú parse_compare)r1 r8 r4 r4 r5 rê + s zParser.parse_notc C sÖ | j jj}| ¡ }g }| j jj}|tkrJt| j | t || ¡ ¡¡ nh| j
|
d¡rn| t d| ¡ ¡¡ nD| j j d¡r¾| j ¡ d¡r¾| j d¡ | t d| ¡ ¡¡ nq¾| j jj}q|sÆ|S tj|||dS )Nr Úinrì r¶ ÚnotinrV )r) r: r8 Ú parse_math1rR Ú_compare_operatorsrq rD r ZOperandrn r r² r´ ZCompare)r1 r8 r} ÚopsÚ
|
token_typer4 r4 r5 rî 1 s&
|
|
|
ÿ zParser.parse_comparec C s^ | j jj}| ¡ }| j jjdkrZt| j jj }t| j | ¡ }||||d}| j jj}q|S )N)r r rV )r) r: r8 Ú parse_concatrR r rq ©r1 r8 rç Úclsrè r4 r4 r5 rñ H s
|
|
zParser.parse_math1c C s^ | j jj}| ¡ g}| j jjdkr<t| j | | ¡ ¡ qt|dkrP|d S tj ||dS )NÚtilder r rV )
|
r) r: r8 Ú parse_math2rR rq rD Úlenr ZConcat)r1 r8 rÊ r4 r4 r5 rõ S s
|
|
|
zParser.parse_concatc C s^ | j jj}| ¡ }| j jjdkrZt| j jj }t| j | ¡ }||||d}| j jj}q|S )N)r r r r rV )r) r: r8 Ú parse_powrR r rq rö r4 r4 r5 rù ] s
|
|
zParser.parse_math2c C sR | j jj}| ¡ }| j jjdkrNt| j | ¡ }tj|||d}| j jj}q|S )NÚpowrV )r) r: r8 Ú parse_unaryrR rq r ZPowræ r4 r4 r5 rû h s
|
|
zParser.parse_pow)Ú with_filterr' c C s | j jj}| j jj}|dkr<t| j tj| d¡|d}n0|dkrdt| j tj| d¡|d}n| ¡ }|
|
|¡}|r| |¡}|S )Nr FrV r ) r) r: rR r8 rq r ZNegrý ZPosrÜ Ú parse_postfixÚparse_filter_expr)r1 rþ rô r8 r r4 r4 r5 rý r s
|
|
|
|
|
|
zParser.parse_unaryc C sr | j j}|jdkrp|jdkr4tj|jdk|jd}n0|jdkrPtjd |jd}ntj|jd|jd}t| j nþ|jdkrÒt| j |jg}|j}| j jjdkr¼| | j jj¡ t| j qtjd
|
|¡|d}n|jd krút| j tj|j|jd}nt|jd
|
kr*t| j | j d d }| j d ¡ nD|jdkr@| ¡ }n.|jdkrV| ¡ }n| dt||j¡ |S )Nr$ )ÚtrueÚfalseÚTrueÚFalse)r r rV )ÚnoneÚNoneÚloadÚstringÚ )ÚintegerÚfloatrÉ T)Úexplicit_parenthesesrQ ÚlbracketÚlbracez unexpected )r) r: rR r` r ÚConstr8 rÛ rq rD rB rx ro Ú
|
parse_listÚ
|
parse_dictr; r )r1 rg r Úbufr8 r4 r4 r5 rÜ s:
|
|
|
|
|
|
|
|
|
|
zParser.parse_primary)rÙ r rN r r' c sÄ j jj}|r j}n |r" j}ntjd fdd }g }d}|rN j d¡ |¡rZq| | ¡ j jj
|
dkrd}nq j jj}q>|s´|r|d S |s´ dt j j¡ tj |d |d
|
S ) a© Works like `parse_expression` but if multiple expressions are
|
delimited by a comma a :class:`~jinja2.nodes.Tuple` node is created.
|
This method could also return a regular expression instead of a tuple
|
if no commas where found.
|
|
The default parsing mode is a full tuple. If `simplified` is `True`
|
only names and literals are parsed. The `no_condexpr` parameter is
|
forwarded to :meth:`parse_expression`.
|
|
Because tuples do not require delimiters and may end in a bogus comma
|
an extra hint is needed that marks the end of a tuple. For example
|
for loops support tuples between `for` and `in`. In that case the
|
`extra_end_rules` is set to ``['name:in']``.
|
|
`explicit_parentheses` is true if the parsing was triggered by an
|
expression in parentheses. This is used to figure out if an empty
|
tuple is a valid expression or not.
|
r] c s j ddS )NFr )r r4 ©r1 r4 r5 r- Æ s z!Parser.parse_tuple.<locals>.parseFr Tr z Expected an expression, got r rV )r) r: r8 rÜ r r ÚExprro rT rD rR r; r ÚTuple) r1 rÙ r rN r r8 r- rÊ Zis_tupler4 r r5 rx ¦ s2
|
|
ÿzParser.parse_tuplec C sj | j d¡}g }| j jjdkrN|r.| j d¡ | j jjdkr>qN| | ¡ ¡ q| j d¡ tj||jdS )Nr Úrbracketr rV ) r) ro r: rR rD r r ÚListr8 )r1 rg Úitemsr4 r4 r5 r è s zParser.parse_listc C s | j d¡}g }| j jjdkrt|r.| j d¡ | j jjdkr>qt| ¡ }| j d¡ | ¡ }| tj|||jd¡ q| j d¡ tj ||jdS )Nr Úrbracer rl rV )
|
r) ro r: rR r rD r ZPairr8 ÚDict)r1 rg r Úkeyr` r4 r4 r5 r ô s zParser.parse_dictc C sB | j jj}|dks|dkr&| |¡}q |dkr>| |¡}q q>q |S )Nr× r rÉ )r) r: rR Úparse_subscriptÚ
|
parse_call©r1 r rô r4 r4 r5 rÿ s
|
zParser.parse_postfixc C s\ | j jj}|dkr | |¡}q |dkr@| j jjdkr@| |¡}q |dkrX| |¡}q qXq |S )NÚpiper$ ÚisrÉ )r) r: rR rz r` Ú
|
parse_testr r r4 r4 r5 r s
|
zParser.parse_filter_exprc C s t | j}|jdkr| jj}t | j |jdkrFtj||jd|jdS |jdkr^| d|j¡ tj |j|jd}tj
|
||d|jdS |jdkr
|
g }| jjjdkrÂ|r²| j d ¡ | | ¡ ¡ q| j d¡ t|d
|
krä|d }ntj|d|jd}tj
|
||d|jdS | d |j¡ d S ) Nr× r$ r rV r
|
zexpected name or numberr r r r r z expected subscript expression)rq r) rR r: r ÚGetattrr` r8 r; r ÚGetitemro rD Úparse_subscribedrú r )r1 r rg Z
|
attr_tokenrÌ rÊ r4 r4 r5 r s6
|
|
|
|
ÿ
|
|
zParser.parse_subscriptc C sò | j jj}| j jjdkr*t| j d g}n*| ¡ }| j jjdkrD|S t| j |g}| j jjdkrn| d ¡ n(| j jjdkr| | ¡ ¡ n
|
| d ¡ | j jjdkrØt| j | j jjdkrÌ| | ¡ ¡ qâ| d ¡ n
|
| d ¡ tj|d|iS )Nrl )r r r8 ) r) r: r8 rR rq r rD r ZSlice)r1 r8 rÊ r r4 r4 r5 r$ > s*
|
|
|
|
|
|
zParser.parse_subscribedc s| j d¡g }g }d }d }d}td d fdd } j jjdkrd|rh j d¡ j jjdkrhqd j jjdkr||d ko|d k t j ¡ }nÀ j jjd krÌ||d k t j ¡ }n j jjd
|
kr2 j ¡ jd kr2||d k j jj} j d ¡ ¡ }|
|
t j |||j d ¡ n,||d koL|d koL| |
|
¡ ¡ d}q6 j d¡ ||||fS )NrÉ F)r} r' c s | s dj¡ d S )Nz+invalid syntax for function call expression)r; r8 )r} ©r1 rg r4 r5 Úensuref s z&Parser.parse_call_args.<locals>.ensurerQ r r rü r$ ru r¶ rV T)r) ro rÄ r: rR rq r r² r` r´ rD r r r8 ) r1 rÊ ÚkwargsÚdyn_argsÚ
|
dyn_kwargsZ require_commar& r r` r4 r% r5 Úparse_call_args^ sD
|
|
|
|
ÿþ
|
zParser.parse_call_argsc C s0 | j j}| ¡ \}}}}tj||||||jdS r¬ )r) r: r* r rÏ r8 )r1 r rg rÊ r' r( r) r4 r4 r5 r s zParser.parse_call)r rÐ r' c C s¶ | j jjdks|r²|s t| j | j d¡}|j}| j jjdkrbt| j |d| j d¡j 7 }q2| j jjdkr| ¡ \}}}}ng }g }d }}tj|||||||j d}d}q |S )Nr r$ r× r> rÉ rV F)
|
r) r: rR rq ro r` r* r ÚFilterr8 ) r1 r rÐ rg r$ rÊ r' r( r) r4 r4 r5 rz s0
|
|
ÿzParser.parse_filterc
|
C s t | j}| jj d¡r(t | j d}nd}| j d¡j}| jjjdkrjt | j |d| j d¡j 7 }q:d }}g }| jjjdkr| ¡ \}}}}nV| jjjdkrè| jj d d
|
d ¡sè| jj d ¡rÎ| d ¡ |
|
¡ } | | ¡} | g}ng }t j |||||||jd}|r t j||jd}|S )Nrì TFr$ r× r> rÉ > r r r r$ rÉ r
|
r r
rã ré zname:isz'You cannot chain multiple tests with isrV )rq r) r: r ro r` rR r* rS r; rÜ rÿ r ZTestr8 rí )
|
r1 r rg Znegatedr$ r( r) r' rÊ Zarg_noder4 r4 r5 r! sD
|
|
|
ø
|
|
ÿzParser.parse_test)rJ r' c sL g g j }|d k r"| j |¡ d d fdd }zú| jr(| jj}|jdkrz|jrn|tj|j|j d t
|
| j q8|jdkr¬t
|
| j || j dd | j d ¡ q8|jd
|
kr | t
|
| j |d k ræ| jjj | ræ W ¢NS | ¡ }t|tr |¡ n
|
|¡ | j d ¡ q8td q8| W 5 |d k rF| j ¡ X S ) Nr] c s8 r4d j } tjd d
| d¡ d d
= d S )Nr rV )r8 rD r rÔ rV ©r~ Z data_bufferr4 r5 Ú
|
flush_dataÝ s
|
z#Parser.subparse.<locals>.flush_datar¢ rV Zvariable_beginTr rO Z block_beginrP zinternal parsing error)rD r0 ra r) r: rR r` r r¡ r8 rq rx ro rS rj r rK ÚextendÚAssertionError)r1 rJ Zadd_datar- rg r[ r4 r, r5 rp Ó sD
|
|
|
|
ÿ
|
|
|
|
zParser.subparsec C s" t j| ¡ dd}| | j¡ |S )z0Parse the whole template into a `Template` node.r rV )r ÚTemplaterp Zset_environmentr" )r1 rr r4 r4 r5 r- s z Parser.parse)NNN)N)NN)N)N)F)..)TFNF)TFNF)T)T)FTNF)F)N)_rÝ Ú
|
__module__Ú __qualname__Ú__doc__ÚstrÚtÚOptionalr6 r ÚintÚTyper; r r rH rI rM rÄ rT r rY r\ ÚUnionrZ rj rs ry 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Î rd rÑ re rÒ rÓ rÔ rÕ ÚtypingÚoverloadrÛ rw rÚ r r rà rá rä rê rî rñ rõ rù rû rý rÜ rx r r r rÿ r r" r# r r$ r* rÏ r rz r! rp r0 r- r4 r4 r4 r5 r! . s& úù üû û ) ÿ þ ýü ÿþ
|
" ÿ
|
þ þ * ÿ þ ûú ûú *
|
|
$ ûú B þ 1 ÿ
|
|
þ ' ÿ
|
þ 1r! )'r3 r: r5 r r Ú
|
exceptionsr r Úlexerr r Ú TYPE_CHECKINGZtyping_extensionsÚter" r ÚTypeVarr¼ r· r rÒ rÎ r
|
Ú frozensetrb rò ZAddZSubZMulZDivZFloorDivZModr r r4 r8 r Ú__annotations__r! r4 r4 r4 r5 Ú<module> sH ôÿú
|
