h f S r SSKrSSKrSSKrSSKJr SSKJr SSKJ r SSK
J r J r SSK
Jr SSKJrJrJr SS KJrJrJr SS
KJr SS KJrJr S S
K J r Sr Sr Sr Sr!Sr"Sr#Sr$Sr%Sr&Sr'Sr(Sr)\RT " S5 r+\RX " S5 r- " S S \5 r. " S S \/5 r0 " S S!5 r1 " S" S#5 r2S$ r3 " S% S&5 r4 " S' S(5 r5 " S) S*\55 r6 " S+ S,5 r7S-S.S/\R " S05 \R " S15 S2.- r8\8Rs S3S45 r8S5\8S6S7\R " \ 5 \R " \ 5 S8.- r:\" \:\Rv 5 r< " S9 S:5 r= " S; S<5 r> " S= S>5 r? " S? S@\@5 rA " SA SB\?5 rBSC rC " SD SE\?5 rD\" SF5 rESHSG jrFg)Ia
This is the Django template system.
How it works:
The Lexer.tokenize() method converts a template string (i.e., a string
containing markup with custom template tags) to tokens, which can be either
plain text (TokenType.TEXT), variables (TokenType.VAR), or block statements
(TokenType.BLOCK).
The Parser() class takes a list of tokens in its constructor, and its parse()
method returns a compiled template -- which is, under the hood, a list of
Node objects.
Each Node is responsible for creating some sort of output -- e.g. simple text
(TextNode), variable values in a given context (VariableNode), results of basic
logic (IfNode), results of looping (ForNode), or anything else. The core Node
types are TextNode, VariableNode, IfNode and ForNode, but plugin modules can
define their own custom node types.
Each Node has a render() method, which takes a Context and returns a string of
the rendered node. For example, the render() method of a Variable Node returns
the variable's value as a string. The render() method of a ForNode returns the
rendered output of whatever was inside the loop, recursively.
The Template class is a convenient wrapper that takes care of template
compilation and rendering.
Usage:
The only thing you should ever use directly in this file is the Template class.
Create a compiled template object with a template_string, then call render()
with a context. In the compilation stage, the TemplateSyntaxError exception
will be raised if the template doesn't have proper syntax.
Sample code:
>>> from django import template
>>> s = '{% if test %}{{ varvalue }}
{% endif %}'
>>> t = template.Template(s)
(t is now a compiled template, and its render() method can be called multiple
times with multiple contexts)
>>> c = template.Context({'test':True, 'varvalue': 'Hello'})
>>> t.render(c)
'Hello
'
>>> c = template.Context({'test':False, 'varvalue': 'Hello'})
>>> t.render(c)
''
N)Enum) BaseContext)localize)conditional_escapeescape)_lazy_re_compile)SafeData
SafeString mark_safe)
get_text_list smart_splitunescape_string_literal)template_localtime) gettext_lazy
pgettext_lazy )TemplateSyntaxError|:.z{%z%}z{{z}}z{#z#}{}zz({%.*?%}|{{.*?}}|{#.*?#})zdjango.templatec $ \ rS rSrSrSrSrSrSrg) TokenType^ r r N) __name__
__module__ __qualname____firstlineno__TEXTVARBLOCKCOMMENT__static_attributes__r F/var/www/html/env/lib/python3.13/site-packages/django/template/base.pyr r ^ s D
C
EGr( r c $ \ rS rSrSS jrS rSrg)VariableDoesNotExiste c Xl X l g Nmsgparams)selfr0 r1 s r) __init__ VariableDoesNotExist.__init__f s r( c 4 U R U R - $ r. r/ r2 s r) __str__ VariableDoesNotExist.__str__j s xx$++%%r( r/ N)r )r r r! r" r3 r7 r' r r( r) r+ r+ e s &r( r+ c @ \ rS rSrS S jrS rS rS r\S 5 r Sr
g)
Originn Nc ( Xl X l X0l g r. )name
template_nameloader)r2 r= r> r? s r) r3 Origin.__init__o s * r( c U R $ r. )r= r6 s r) r7 Origin.__str__t s yyr( c T SU R R < SU R < S3$ )N) __class__r! r= r6 s r) __repr__Origin.__repr__w s !% ! NN) r r r! r" r3 r7 rG rL propertyrO r' r r( r) r: r: n s+
I
r( r: c < \ rS rSrS
S jrS rS rS rS rS r S r
g) Template Nc Uc SSK Jn UR 5 nUc [ [ 5 nX0l X l X@l [ U5 U l U R 5 U l
g )Nr )Engine) enginerW get_defaultr: UNKNOWN_SOURCEr= originstrsourcecompile_nodelistnodelist)r2 template_stringr[ r= rX rW s r) r3 Template.__init__ sT
> &'')F >N+F /* --/
r( c z SU R R < SU R S S R SS5 < S3$ )NrD template_string="
...">)rF r! r] replacer6 s r) rG Template.__repr__ s4 NN ' ' KK $ $T2 .
r( c 8 U R R U5 $ r. )r_ renderr2 contexts r) _renderTemplate._render s }}##G,,r( c l UR R U 5 UR cF UR U 5 U R Ul U R
U5 sSSS5 sSSS5 $ U R
U5 sSSS5 $ ! , ( d f O= f SSS5 g! , ( d f g= f)z)Display stage -- can be called many timesN)render_context
push_statetemplate
bind_templater= r> rn rl s r) rk Template.render s
#
#
.
.t
4 ' **40,0IIG) <<0 10 5
4 ||G,
5
4000 5
4
4s( B%"B
B%0B%
B B%%
B3c U R R ( a [ U R 5 nO[ U R 5 nUR 5 n[
UU R R U R R U R 5 n UR 5 nUR U l U$ ! [ aA nU R R ( a U R XUR 5 Ul e SnAff = f)z
Parse and compile the template source into a nodelist. If debug
is True and an exception occurs during parsing, the exception is
annotated with contextual line information where it occurred in the
template source.
N)rX debug
DebugLexerr] LexertokenizeParsertemplate_librariestemplate_builtinsr[ parse
extra_data Exceptionget_exception_infotokentemplate_debug)r2 lexertokensparserr_ es r) r^ Template.compile_nodelist s ;; t{{+E$++&E ! KK * * KK ) ) KK
||~H $ / /DOO {{ #'#:#:1gg#F s "B; ;
D$++#>?IC} D 78 E 67 t{{3 45 fT[[-C&D E FD @ L!!T)*U1H} 45 :)..+,G
(V 4 KK$$
./ :9G :s )D& &D;:D;)rX r r= r_ r[ r] NNN) r r r! r" r3 rG rn rk r^ r r' r r( r) rT rT s! 0"
--:L
r( rT c # # Sv U R S5 nUS: a$ US- v U R SUS- 5 nUS: a M$ [ U 5 S- v g 7f)Nr re r )findr )template_sourceps r) r r s[
G T"A
q&!e q1u - q& o
""s >AAc * \ rS rSrSS jrS rS rSrg)Tokeni$ Nc 4 Xl X l X@l X0l g)a
A token representing a string from the template.
token_type
A TokenType, either .TEXT, .VAR, .BLOCK, or .COMMENT.
contents
The token source string.
position
An optional tuple containing the start and end index of the token
in the template source. This is used for traceback information
when debug is on.
lineno
The line number the token appears on in the template source.
This is used for traceback information and gettext files.
N)
token_typecontentslinenor )r2 r r r r s r) r3 Token.__init__% s & %
r( c U R R R 5 nSU< SU R S S R SS5 < S3$ )NrD z token: "rd re rf rg )r r=
capitalizer rh )r2
token_names r) rG Token.__repr__= sB __))446
MM#2 & &tR 0
r( c ` / n[ U R 5 nU H nUR S5 ( af US S- nU/nUR U5 ( d4 [ U5 nUR U5 UR U5 ( d M4 SR
U5 nUR U5 M U$ )N)z_("z_('r ) )r
r
startswithendswithr r join)r2 splitbitsbitsentinel trans_bits r) split_contentsToken.split_contentsD s 4==)C~~n-- q6C< E ,,x00 t*C $$S) ,,x00 hhy) LL r( )r r r r rQ )r r r! r" r3 rG r r' r r( r) r r $ s !0
r( r c , \ rS rSrS rS rS rS rSrg)ry iT c Xl SU l g )NFr` verbatim)r2 r` s r) r3 Lexer.__init__U s .
r( c SU R R < SU R S S R SS5 < SU R < S3$ )NrD rc rd re rf z...", verbatim=rE )rF r! r` rh r r6 s r) rG Lexer.__repr__Y s= NN ' ' " % - -dB 7 MM
r( c SnSn/ n[ R U R 5 HF nU( a5 UR U R USX!5 5 X$R S5 -
nU( + nMH U$ )z7
Return a list of tokens from a given template_string.
Fr Nre )tag_rer r` r create_tokencount)r2 in_tagr result token_strings r) rz Lexer.tokenize` sk "LL)=)= >L
d / / dF ST,,T22 ZF ?
r( c N U( Ga USS nU[ :X a USS R 5 nU R ( a2 X`R :w a [ [ R
XU5 $ SU l OUSS S; a
SU- U l [ [ R XbU5 $ U R ( d_ USS R 5 nU[ :X a [ [ R XbU5 $ U[ :X d e[ [ R XbU5 $ [ [ R
XU5 $ ) z
Convert the given token string into a new Token object and return it.
If in_tag is True, we are processing something that matched a tag,
otherwise it should be treated as a literal string.
r r FN )r z verbatim zend%s) BLOCK_TAG_STARTstripr r r r# r% VARIABLE_TAG_STARTr$ COMMENT_TAG_STARTr& )r2 r r r r token_startcontents r) r Lexer.create_tokenn s 'q+Ko-&q,224== --/ $Y^^\V TT$)DM Ra[$==$+g$5DM Y__gHH==&q,224 "44 6JJ"&7777 Y . .6JJY^^\VDDr( r N) r r r! r" r3 rG rz r r' r r( r) ry ry T s
Er( ry c & \ rS rSrS rS rS rSrg)rx i c # # Sn[ R U R 5 H! nUR 5 u p4X4v X44v UnM# U[ U R 5 4v g 7f)Nr )r finditerr` spanr )r2 lastmatchr r s r) _tag_re_split_positions"DebugLexer._tag_re_split_positions s] __T%9%9:E JE+ * D ;
C,,---s A!A#c # l # U R 5 H nU R [ U6 U4v M g 7fr. )r r` slice)r2 r s r)
_tag_re_splitDebugLexer._tag_re_split s3 446H&&uh'78(B B 7s 24c SnSn/ nU R 5 HG u pEU( a4 UR U R XEX!5 5 X$R S5 -
nU( + nMI U$ )z
Split a template string into tokens and annotates each token with its
start and end position in the source. This is slower than the default
lexer so only use it when debug is True.
Fr re )r r r r )r2 r r r r r s r) rz DebugLexer.tokenize sf &*&8&8&: "L
d / / WX,,T22 ZF ';
r( r N)r r r! r" r r rz r' r r( r) rx rx s .Cr( rx c t \ rS rSrSS jrS rSS jrS rS rS r SS jr
S
r S r S r
S
rS rS rS rSrg)r{ i Nc [ [ U5 5 U l 0 U l 0 U l / U l 0 U l Uc 0 nUc / nX l U H nU R U5 M X@l g r. )
listreversedr tagsfilters
command_stackr libraries add_libraryr[ )r2 r r builtinsr[ builtins r) r3 Parser.__init__ sl 8F+, I H" G W % r( c T SU R R < SU R < S3$ )NrD z tokens=rE )rF r! r r6 s r) rG Parser.__repr__ s #'>>#>#> LLr( c Uc / n[ 5 nU R ( Gau U R 5 nUR R nUS:X a( U R U[
UR 5 U5 GO
US:X aj UR ( d U R USUR - 5 e U R UR 5 n[ U5 nU R X'U5 OUS:X a UR R 5 S nX; a U R U5 U$ U R R# X45 U R$ U n W " X5 n
U R X*U5 U R R- 5 U R ( a GMu U( a U R/ U5 U$ ! [ a nU R X65 eSnAff = f! [ a U R USUR - 5 ef = f! [& a U R) X8U5 Nf = f! [* a nU R X65 eSnAff = f)aH
Iterate through the parser tokens and compiles each one into a node.
If parse_until is provided, parsing will stop once one of the
specified tokens has been reached. This is formatted as a list of
tokens, e.g. ['elif', 'else', 'endif']. If no matching token is
reached, raise an exception with the unclosed block tag details.
Nr r z Empty variable tag on line %dr zEmpty block tag on line %d)NodeListr
next_tokenr valueextend_nodelistTextNoder errorr compile_filterr VariableNoder r
prepend_tokenr r r KeyErrorinvalid_block_tagr popunclosed_block_tag) r2 parse_untilr_ r r filter_expressionr var_nodecommand compile_funccompiled_results r) r~ Parser.parse s K:kkkOO%E ))//JQ$$Xx/GOq ~~ ** > M /(,(;(;ENN(K% ((9:$$X?q Y #nn 2 2 4Q 7G ) &&u-#O ""))7*:;H#'99W#5L
/&24&?O $$XF""&&(] kkk^ # #K 0I + / **U../ " Y **U,H5<<,WXXY H**5;GH ! / **U../sN -F1 - G ?H H# 1
G;G G*G> H H #
I-H>>Ic U R ( aR U R 5 nUR [ R :X a UR
U:X a g U R ( a MR U R
U/5 g r. )r r r r r% r r )r2 endtagr s r) skip_pastParser.skip_past sR kkOO%E 9??2u~~7O kkk
)r( c UR ( a& UR ( a U R USU- 5 e[ U[ 5 ( d SUl X2l U R Ul UR U5 g )Nz)%r must be the first tag in the template.T)
must_be_firstcontains_nontextr rJ r r r[ r )r2 r_ noder s r) r Parser.extend_nodelist sd (";";**;dB
$))(,H %
kk r( c t [ U[ 5 ( d [ U5 n[ US5 ( d Xl U$ )a
Return an exception annotated with the originating token. Since the
parser can be called recursively, check if a token is already set. This
ensures the innermost token is highlighted if an exception occurs,
e.g. a compile error within the body of an if statement.
r )rJ r r hasattrr )r2 r r s r) r Parser.error$ s2 !Y''#A&Aq'""Gr( c
U( a@ U R USUR U[ U Vs/ s H nSU- PM
snS5 4- 5 eU R USUR U4- 5 es snf )Nz]Invalid block tag on line %d: '%s', expected %s. Did you forget to register or load this tag?z'%s'orzPInvalid block tag on line %d: '%s'. Did you forget to register or load this tag?)r r r )r2 r r r r s r) r Parser.invalid_block_tag1 s **7 LL!{"C{!6A:{"CTJ
jj
#(<<"9
:
#Ds A)c U R R 5 u p#SUR USR U5 4- nU R X45 e)Nz6Unclosed tag on line %d: '%s'. Looking for one of: %s.z, )r r r r r )r2 r r r r0 s r) r Parser.unclosed_block_tagC sO ++//1F LL IIk "J
jj$$r( c 6 U R R 5 $ r. )r r r6 s r) r Parser.next_tokenL s {{ r( c : U R R U5 g r. )r r r2 r s r) r Parser.prepend_tokenO s 5!r( c U R S g )N)r r6 s r) delete_first_tokenParser.delete_first_tokenR s
KKOr( c U R R UR 5 U R R UR 5 g r. )r updater )r2 libs r) r Parser.add_libraryU s. " CKK(r( c [ X5 $ )z)
Convenient wrapper for FilterExpression
)FilterExpressionr! s r) r Parser.compile_filterY s ,,r( c Z XR ; a U R U $ [ SU- 5 e)NzInvalid filter: '%s')r r )r2 filter_names r) find_filterParser.find_filter_ s, ,, &<< , ,%&<{&JK Kr( )r r r r r[ r r r r. )r r r! r" r3 rG r~ r r r r r r r r% r r r0 r' r r( r) r{ r{ sK 0M=~*
$%!" )- Lr( r{ zf
(?:%(i18n_open)s%(strdq)s%(i18n_close)s|
%(i18n_open)s%(strsq)s%(i18n_close)s|
%(strdq)s|
%(strsq)s)
z"[^"\\]*(?:\\.[^"\\]*)*"z'[^'\\]*(?:\\.[^'\\]*)*'_(r )strdqstrsq i18n_open
i18n_closere rf a
^(?P%(constant)s)|
^(?P[%(var_chars)s]+|%(num)s)|
(?:\s*%(filter_sep)s\s*
(?P\w+)
(?:%(arg_sep)s
(?:
(?P%(constant)s)|
(?P[%(var_chars)s]+|%(num)s)
)
)?
)z[-+.]?\d[\d.e]*z\w\.)constantr var_chars
filter_separg_sepc N \ rS rSrSrSrS rS S jrS r\ " \5 rS r
S r S r g
) r, i aZ
Parse a variable token and its optional filters (all as a single string),
and return a list of tuples of the filter name and arguments.
Sample::
>>> token = 'variable|default:"Default value"|date:"Y-m-d"'
>>> p = Parser('')
>>> fe = FilterExpression(token, p)
>>> len(fe.filters)
2
>>> fe.var
)r r varis_varc d Xl [ R U5 nS n/ nSnU GH0 nUR 5 nXh:w a [ SUS U < SXU < SXS < 35 eUcJ US =n ( a [ U 5 R
0 5 nOUS =n
c [ SU- 5 e[ U
5 nOUS n / n US =n
( a, U R S [ U
5 R
0 5 45 O(US
=n( a U R S [ U5 45 UR U 5 nU R XU 5 UR X45 UR 5 nGM3 U[ U5 :w a [ S XS < S
U< S35 eXPl
X@l [ U[
5 U l g ! [ a S n Njf = f)Nr z!Could not parse some characters: r r7 r< z'Could not find variable at start of %s.r/ constant_argFvar_argTz Could not parse the remainder: 'z' from '')r filter_rer r r Variableresolver+ r r0
args_checkr r r r< rJ r= )r2 r r matchesvar_objr r r r r7 r< r/ r r? r@ filter_funcs r) r3 FilterExpression.__init__ s
$$U+ EKKME})"',50A5=R $Z 0080'"*8"4"<"(F(Fr(J KL %i 00W0KKx'8 9: $ 0 0 = $? 2399;D; < 3u: % $U|U4
(3 7 0 '"&'s +F F/.F/c " U R ( a U R R U5 nO U R nU R H u pV/ nU HH u pU( d UR [ U 5 5 M( UR U R U5 5 MJ [ USS5 ( a [ X1R 5 n[ USS5 ( a U" U/UQ7SUR 06n
O U" U/UQ76 n
[ USS5 ( a" [ U[ 5 ( a
[ U
5 nM U
nM U$ ! [ aS U( a S n GN UR R
R nU( a SU; a X@R - s $ Us $ Un GNRf = f)Nz%sexpects_localtimeFneeds_autoescape
autoescapeis_safe)r= r< rD r+ rs rX string_if_invalidr r r getattrr use_tzrM rJ r ) r2 rm ignore_failuresobjrO funcr arg_valslookupargnew_objs r) rD FilterExpression.resolve sU ;;
0hh&&w/ ((C ,,JDH # OOIcN3 OOCKK$89 $
t 0%88(nn=t /77 sMHMw/A/AM s.X.tY..:c83L3L ( ! '"
? (
0" C(/(8(8(?(?(Q(Q%( #44#4xx#? ?#4 4 /
0s# D1 1F;FFF
Fc [ U5 n[ U5 S- n[ R " U5 n[ R " U5 u n pV n[ U5 n[ U=( d / 5 nX7U-
: d X7: a [ SXU-
U4- 5 eg)Nr z%%s requires %d arguments, %d providedT)r r inspectunwrapgetfullargspecr ) r= rT providedplenr _defaultsalendlens r) rE FilterExpression.args_check s >8}q ~~d#(/(>(>t(D%aaA4y8>r" $; 4;%74d:SS
r( c U R $ r. )r r6 s r) r7 FilterExpression.__str__ s zzr( c T SU R R < SU R < S3$ )NrD r rE )rF r! r r6 s r) rG FilterExpression.__repr__ s NN 7 7DDr( )r r= r r< NF)
r r r! r" __doc__ __slots__r3 rD rE staticmethodr7 rG r' r r( r) r, r, s6 6I,4\#J$ j)JEr( r, c : \ rS rSrSrSrS rS rS rS r S r
S r g
) rC i a
A template variable, resolvable against a given context. The variable may
be a hard-coded string (if it begins and ends with single or double quote
marks)::
>>> c = {'article': {'section':'News'}}
>>> Variable('article.section').resolve(c)
'News'
>>> Variable('article').resolve(c)
{'section': 'News'}
>>> class AClass: pass
>>> c = AClass()
>>> c.article = AClass()
>>> c.article.section = 'News'
(The example assumes VARIABLE_ATTRIBUTE_SEPARATOR is '.')
)r< literallookups translatemessage_contextc v Xl S U l S U l SU l S U l [ U[ 5 ( d [ S[ U5 - 5 e SU; d SUR 5 ; a [ U5 U l US S:X a [ eg [ U5 U l g ! [ a USS S:X a US S :X a S
U l USS n [ [ U5 5 U l g ! [ aK [ S - U; d US S :X a [! S U- 5 e[# UR% [ 5 5 U l g f = ff = f)
NFz+Variable must be a string or number, got %sr r r$ r r r2 r Tr` z=Variables and attributes may not begin with underscores: '%s')r< rn ro rp rq rJ r\ TypeErrortypelowerfloat
ValueErrorintr r VARIABLE_ATTRIBUTE_SEPARATORr tupler )r2 r< s r) r3 Variable.__init__ sC # #s## IDQTI UV V# N czSCIIK / $Sz r7c>$$ " #3x N1Qx4 CGsN "&!Bi
N ()@)E F
N 0#5<A#
-;=@A %SYY/K%L M
N Ns1 9B
B (D8C AD40D83D44D8c N U R b U R U5 nO U R nU R ( ah [ U[
5 nUR
SS5 nU( a [ U5 OUnU R ( a [ U R U5 $ [ U5 $ U$ )z.Resolve this variable against a given context.%z%%) ro _resolve_lookuprn rp rJ r rh r rq r r )r2 rm r rN msgids r) rD Variable.resolveN s << #((1E LLE >> 1GMM#t,E(/Ie$UE##$T%9%95AA#E** r( c T SU R R < SU R < S3$ )NrD : rE )rF r r< r6 s r) rG Variable.__repr__` s !^^ 4 4dhh??r( c U R $ r. )r< r6 s r) r7 Variable.__str__c s xxr( c Un U R Hj n X# n[ U5 ( d M [ USS5 ( a M. [ USS5 ( a" UR R R nMb U" 5 nMl U$ ! [ [ [ [ [
4 a [
U[ 5 ( a [ [ U5 U5 ( a [ e[ X#5 n N! [ [ 4 ad [
U[ 5 ( d U[ U5 ; a e U[ U5 n GN! [
[ [ [ 4 a [ SX245 ef = ff = ff = f! [ a [" R$ " U5 n UR' 5 e ! [ a& UR R R n GM f = f! [ a& UR R R n GM f = ff = f! [( aj n[ USS5 =( d Sn[* R- SWUS S
9 [ US S5 ( a& UR R R n SnAU$ e SnAff = f) z
Perform resolution of a real variable (i.e. not a literal) against the
given context.
As indicated by the method's name, this method is an implementation
detail and shouldn't be called by external code. Use Variable.resolve()
instead.
z Failed lookup for key [%s] in %rdo_not_call_in_templatesF alters_datar> Nunknownz9Exception while resolving variable '%s' in template '%s'.T)exc_infosilent_variable_failure)ro rs AttributeErrorr rw r rJ r rP rt dirrx r+ callablers rX rO r[ signaturebindr loggerrw )r2 rm currentr r r r> s r) r~ Variable._resolve_lookupf sT ? || %lG6 G$$ w(BEJJ -??")"2"2"9"9"K"K*&-iGI $@ w ">8ZT %g{;; M3A A #1 0")'"7 %~6 )'; ? ?C3w.>.E.E.W.WG!X $. T*1*:*:*A*A*S*S T * #G_d C PyM LLK
q3U;;!**11CC s G: B G: AG: 3E :G: E A C" G: "5ED*&E'G: *(E EEG:
G7(G?FG7*G :G7;G: ?G G7*G3-G7.G: 2G33G77G: :
I.A I)(I))I.)rn ro rq rp r< N) r r r! r" rj rk r3 rD rG r7 r~ r' r r( r) rC rC s, $ NI,N\$@Kr( rC c 2 \ rS rSrSrSrSrS rS rS r Sr
g) Nodei F)r_ Nc g)z'
Return the node rendered as a string.
Nr rl s r) rk Node.render s
r( c U R U5 $ ! [ a nUR R R ( a [ US5 ( d Xl [ US5 ( dw UR R R UR R :X a? UR R R UUR R 5 Ul e SnAff = f)z
Render the node. If debug is True and an exception occurs during
rendering, the exception is annotated with contextual line information
where it occurred in the template. For internal usage this method is
preferred over using the render method directly.
_culprit_noder N) rk r rs rX rw r r rq r[ r r r )r2 rm r s r) render_annotatedNode.render_annotated s ;;w' ' &&,, q/22&*O #344 ..77>>!//BXBXX ..77JJ OO 1 1 $
s
C'CC""C'c / n[ X5 ( a UR U 5 U R H8 n[ XS5 nU( d M UR UR U5 5 M: U$ )zR
Return a list of all nodes (within this node and its nodelist)
of the given type
N)rJ r child_nodelistsrP extendget_nodes_by_type)r2 nodetypenodesattrr_ s r) r Node.get_nodes_by_type s_
d % % LL ((D t40Hx X 7 7 AB ) r( r ) r r r! r" r r r rk r r r' r r( r) r r s" M#O E
4 r( r c $ \ rS rSrSrS rS rSrg)r i Fc
~ [ SR U Vs/ s H o"R U5 PM sn5 5 $ s snf Nrf )r
r r )r2 rm r s r) rk NodeList.render s1 "''d"Sdd#8#8#Ad"STUU"Ss : c \ / nU H# nUR UR U5 5 M% U$ )z,Return a list of all nodes of the given type)r r )r2 r r r s r) r NodeList.get_nodes_by_type s- D LL//9 : r( r N)r r r! r" r rk r r' r r( r) r r s Vr( r c 0 \ rS rSrSrS rS rS rS rSr g) r i r c Xl g r. s)r2 r s r) r3 TextNode.__init__ s r( c Z SU R R < SU R S S < S3$ )NrD r rE )rF r r r6 s r) rG TextNode.__repr__ s! !^^ 4 4dffSbkBBr( c U R $ r. r rl s r) rk TextNode.render s vv
r( c U R $ )z
Return the given value.
The default implementation of this method handles exceptions raised
during rendering, which is not necessary for text nodes.
r rl s r) r TextNode.render_annotated s
vv
r( r N)
r r r! r" r r3 rG rk r r' r r( r) r r s OCr( r c [ XR S9n [ XR S9n UR ( a4 [ [
U 5 [ 5 ( d [ U 5 n [ U 5 $ [ U 5 $ )z
Convert any value to a string to become part of a rendered template. This
means escaping, if required, and conversion to a string. If value is a
string, it's expected to already be translated.
)rQ )use_l10n) r rQ r r rM
issubclassrt r\ r )r rm s r) render_value_in_contextr sZ
u^^ r r6 s r) rG VariableNode.__repr__& s $t'='===r( c p U R R U5 n[ X!5 $ ! [ a gf = fr )r rD r r )r2 rm outputs r) rk VariableNode.render) s@ ++33G8r( r z(?:(\w+)=)?(.+)c " U ( d 0 $ [ R U S 5 nU=( a US nU( d# U( d 0 $ [ U 5 S: d U S S:w a 0 $ 0 nU ( a U( aC [ R U S 5 nU( a
US ( d U$ UR 5 u pgU SS2 O([ U 5 S: d U S S:w a U$ U S U S pvU SS2 UR U5 XV' U ( a U( d U S S:w a U$ U SS2 U ( a M U$ )a,
Parse token keyword arguments and return a dictionary of the arguments
retrieved from the ``bits`` token list.
`bits` is a list containing the remainder of the token (split by spaces)
that is to be checked for arguments. Valid arguments are removed from this
list.
`support_legacy` - if True, the legacy format ``1 as foo`` is accepted.
Otherwise, only the standard ``foo=1`` format is allowed.
There is no requirement for all remaining token ``bits`` to be keyword
arguments, so return the dictionary as soon as an invalid argument format
is reached.
r r r asNr and)kwarg_rer r groupsr )r r support_legacyr kwarg_formatkwargskeyr s r) token_kwargsr 8 s NN47 #E%U1XL I t9q=DGtOI
F
NN47+Ea
JCRaR4y1}Q4
a$q'RaR ++E2 Aw%
RaR! $" Mr( ri )Grj r[ loggingreenumr django.template.contextr django.utils.formatsr django.utils.htmlr r django.utils.regex_helperr django.utils.safestringr r
r django.utils.textr r
r django.utils.timezoner django.utils.translationr r
exceptionsr FILTER_SEPARATORFILTER_ARGUMENT_SEPARATORry r
BLOCK_TAG_ENDr VARIABLE_TAG_ENDr COMMENT_TAG_ENDSINGLE_BRACE_STARTSINGLE_BRACE_ENDrZ compiler getLoggerr r r r+ r: rT r r ry rx r{ constant_stringrh filter_raw_stringVERBOSErB r, rC r r r r r r r r r r( r) r s 2h / ) 8 6 C C Q Q 4 @ + "
$
0 1 , - &9 & 8N
N
b#- -`:E :Ez DpL pLl )
(4 ))C.
"))$3 )) ,-yy23 &
.
; |E |E~f fR3 3l
t
t ,
84 8* . /,r(