o .df@sdZddlmZddlZddlZddlZddlZddlZddl Z ddl m Z ddl m Z ddl mZddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z ddlm!Z!ddlm"Z"ddl#m$Z$ddl%m&Z&ddl'm(Z(ddl'm)Z)ddl'm*Z*ddl'm+Z+ddl'm,Z,ddl'm-Z-dd l.m/Z/dd!l0m1Z1dd"l0m2Z2dd#l0m3Z3dd$l0m4Z4dd%l0m5Z5dd&l0m6Z6erdd'l#m7Z7dd(l8m9Z9dd)l:m;Z;d*ZffZ?ee=e@fZAGd+d,d,ee=e@fZBeBZCefdOd3d4ZDefdOd5d6ZEefdOd7d8ZFdPd:d;ZGdPdd?ZIGd@dAdAZJGdBdCdCeJZKGdDdEdEeJZLGdFdGdGeKeLZMe1dHdQdMdNZNdS)RzLiquid template render context.) annotationsN)contextmanager)partial)reduce)StringIO)cycle)getitem)mul) TYPE_CHECKING)Any) Awaitable)Callable)Dict)Iterator)List)Mapping)MutableMapping)Optional)Sequence)TextIO)Union)Mode)ReadOnlyChainMap)ContextDepthError)Error)LocalNamespaceLimitError)LoopIterationLimitError)NoSuchFilterFunc)lookup_warning)LimitedStringIO) UNDEFINED)DebugUndefined)StrictDefaultUndefined)StrictUndefined) Undefined) is_undefined) Environment)ForLoop) BoundTemplate) Contextr!get_itemr%rr"r#VariableCaptureContextr$c@s8eZdZdZdddZdd d Zdd dZdddZdS)BuiltInz)r/rB)__name__ __module__ __qualname____doc__r6r=rArDr3r3r3r5r,Gs    r,objr item_getterCallable[[Any, str], object]r/r.c Cs>z||dWStttfyt|tjjrt|YSwNsizer< IndexError TypeError isinstance collectionsabcSizedlenrJrKr3r3r5 _liquid_size`s  rXc Csxz||dWStttfy;t|trt|tjjr-|r-tt | ddYSt|tjj r:|dYSwNfirstr r<rPrQrRr8rSrTrlist itertoolsisliceitemsrrWr3r3r5 _liquid_firstks   rac CsJz||dWStttfy$t|trt|tjjr#|dYSwNlastr<rPrQrRr8rSrTrrWr3r3r5 _liquid_lastzs   rf'Callable[[Any, str], Awaitable[object]]c sFz ||dIdHWStttfy"t|tjjr!t|YSwrMrOrWr3r3r5_liquid_size_asyncs rhc sz ||dIdHWStttfy?t|trt|tjjr1|r1tt | ddYSt|tjj r>|dYSwrYr\rWr3r3r5_liquid_first_asyncs  ric sRz ||dIdHWStttfy(t|trt|tjjr'|dYSwrbrerWr3r3r5_liquid_last_asyncs  rjc@s\eZdZdZdZ       dldmddZdnddZdoddZefdpd$d%Z efdpd&d'Z efdqd)d*Z efdqd+d,Z drd.d/Z dsd1d2Zdsd3d4Zdtd6d7Zdtd8d9Zdud:d;ZdudruOptional[Context]rsrqrxOptional[BoundTemplate]c Cs|||_||_i|_|p i|_i|_t|j|jt|j|_idid|_g|_ |p)g|_ |jj |_ ||_ ||_ ||_||_dS)N)cycles ifchanged stopindex)rorxrrrprmrbuiltinrvrwrtrnrlrkrursrq) r4rorprnr{rursrqrxr3r3r5__init__s"     zContext.__init__r7r8valr r/NonecCs2||j|<|jjr||jjkrtddSdS)z(Add `val` to the context with key `key`.zlocal namespace limit reachedN)rrrolocal_namespace_limitget_size_of_localsrr4r7rr3r3r5assigns zContext.assigncCs*|jjsdStdd|jD|jS)aReturn the "size" or a "score" for the current local namespace. This is used by the optional local namespace resource limit. Override `get_size_of_locals` to customize how the limit is calculated. Be sure to consider `self.local_namespace_size_carry` when writing a custom implementation of `get_size_of_locals`. The default implementation uses `sys.getsizeof()` on each of the local namespace's values. It is not a reliable measure of size in bytes. rcss|] }tj|ddVqdS)r[defaultN)sys getsizeof).0rJr3r3r5 &sz-Context.get_size_of_locals..)rorsumrrvaluesrqr@r3r3r5rs  zContext.get_size_of_localspath ContextPathrr.c Cst|tr |||S|d|dd}}t|tsJ|||}|rzt|j||WStttfy}zCt|trPd|d|ddd|D}n|d |dd d|D}|t krs|j j ||d WYd}~S|WYd}~Sd}~ww|S) @Return the value at path `path` if it is in scope, else default.rr[Nz key error: z, r~cSg|]}d|dqS[]r3rir3r3r5 9zContext.get..: cSrrr3rr3r3r5r<rnamehint) rRr8_resolverrr<rPrQjoinr ro undefined)r4rrrr`rJerrrr3r3r5get*s,    ""z Context.getc st|tr |||S|d|dd}}t|tsJ|||}|rq|j}z|D] }|||IdH}q,W|Stttfyp}z(|tkre|jj ||d|d dd|DdWYd}~SWYd}~|Sd}~ww|S) rrr[Nrr~cSrrr3rr3r3r5rYrz%Context.get_async..r) rRr8r getitem_asyncr<rPrQr rorr) r4rrrr`rJ_gir-rr3r3r5 get_asyncGs0      zContext.get_asyncrcCs |||S)zReturn the object/value at `name` in the current scope. This is like `get`, but does a single, top-level lookup rather than a chained lookup from a sequence of keys. )rr4rrr3r3r5resolve^s zContext.resolvecCs<z|j|WSty|tkr|j|YS|YSwN)rvr<r rorrr3r3r5rfs  zContext._resolveCallable[..., object]c Csz|jj|}Wnty}z td|d|d}~wwi}t|ddr*||d<t|ddr5|j|d<|rXt|d rPt|fi|}t|jfi||_|St|fi|S|S) z+Return the filter function with given name.zunknown filter ''N with_contextFcontextwith_environment environment filter_async)rofiltersr<rgetattrhasattrrr)r4r filter_funcrkwargs _filter_funcr3r3r5filterns,    zContext.filterr(cCs |j|S)z%Load a template from the environment.)ro get_templater4rr3r3r5rs zContext.get_templatecs|j|IdHS)z4Load a template from the environment asynchronously.N)roget_template_asyncrr3r3r5rszContext.get_template_asyncrcKs|jj||fi|S)z7Load a template referencing the current render context.)roget_template_with_contextr4rrr3r3r5rsz!Context.get_template_with_contextcs|jj||fi|IdHS)z0An async version of `get_template_with_context`.N)roget_template_with_context_asyncrr3r3r5rsz'Context.get_template_with_context_asynccCs |j|d}|d|j|<|S)z1Increment the named counter and return its value.rr[rmrr4rrr3r3r5 incrementszContext.incrementcCs |j|dd}||j|<|S)z1Decrement the named counter and return its value.rr[rrr3r3r5 decrements zContext.decrement group_nameargsSequence[object]cCsB|t|f}|jd}||vrttt|||<|t||S)z9Return the next item in the cycle of the given arguments.r)tuplerwrrangerVnext)r4rrr7 namespacer3r3r5rs  z Context.cycler0cCs ||jdkr||jd<dSdS)z1Return True if the `ifchanged` value has changed.rTF)rw)r4rr3r3r5rs zContext.ifchangedindex Optional[int]cCs0|dur ||jd|<|S|jd|d}|S)z+Set or return the stop index of a for loop.Nrr)rwr)r4r7ridxr3r3r5rs zContext.stopindexr NamespaceIterator[Context]ccsp|j|jjkrtd|j}|r||_|j|z|VW|r&||_|jdS|r2||_|jw)z7Extend this context with the given read-only namespace.z9maximum context depth reached, possible recursive includeN)rvrNrocontext_depth_limitrrxpushpop)r4rrx _templater3r3r5extends"  zContext.extendforloopr'c csl||j|j|||}z |VW|jn|jwWddS1s/wYdS)zCJust like `Context.extend`, but keeps track of ForLoop objects too.N)raise_for_loop_limitlengthrtappendrr)r4rrrr3r3r5loops   "z Context.loopUnion[Undefined, object]cCs,z|jdWSty|jdYSw)z3Return the last ForLoop object from the loop stack.rd parentloop)rtrProrr@r3r3r5rs   zContext.parentlooprcCs>|jjrttdd|jD||j|jjkrtddSdS)zIRaise a `LoopIterationLimitError` if loop stack is bigger than the limit.cs|]}|jVqdSrrrrr3r3r5rz/Context.raise_for_loop_limit..zloop iteration limit reachedN)roloop_iteration_limitrr rtrsr)r4rr3r3r5rszContext.raise_for_loop_limitFcarry_loop_iterations block_scopec Cs|j|jjkr td|rttdd|jD|j}nd}|r>|j|jt ||j ||jd||| d}|j d|j d<n|j|jt ||j ||jd||| d}|pX|j|_|S)zyReturn a copy of this render context. Local variables and other state for stateful tags are not copied. z8maximum context depth reached, possible recursive rendercsrrrrr3r3r5r rzContext.copy..r[rprnr{rursrqextends)rkrorrrr rtrs __class__rrvrrwrprx)r4rrnrrxrrsctxr3r3r5copysB     z Context.copyexcrcCsB|jjtjkr ||jjtjkrtjt|t|j dddSdS)z:Ignore, raise or convert the given exception to a warning.r?)category stacklevelN) romoderSTRICTWARNwarningswarnr8rr)r4rr3r3r5error-s z Context.errorbufOptional[TextIO]rcCs8|jjdur tSt|tr|jnd}t|jj|dS)zGReturn a new StringIO object that respects the configured stream limit.Nr)limit)rooutput_stream_limitrrRrrN)r4rcarryr3r3r5 get_buffer6s zContext.get_bufferrJcCsLt|dr |}|dkrt|S|dkrt|S|dkr!t|St||S)CItem getter with special methods for arrays/lists and hashes/dicts. __liquid__rNrZrc)rrrXrarfrclsrJr7r3r3r5r>s  zContext.getitemcsvd dd}t|dr|}|d krt||Id HS|d kr't||Id HS|d kr3t||Id HS|||Id HS)rrJr r7r/r.cs&t|dr||IdHSt||S)N__getitem_async__)rrr)rJr7r3r3r5 _get_itemQs  z(Context.getitem_async.._get_itemrrNNrZrcrJr r7r r/r.)rrrhrirj)rrJr7rr3r3r5rMs  zContext.getitem_async)NNrNr[rN)ror&rpryrnrzr{r>rur|rsr>rqr>rxr}r7r8rr r/rrErrrr.r/r.rr8rr.r/r rr8r/r)rr8r/r()rr8rr8r/r(rr8r/r>rr8rrr/r.)rr8r/r0r)r7r8rrr/r>)rrrxr}r/r)rrrr'r/r)r/r)r[)rr>r/r)NFNF) rrrnrzrr0rxr}rr0r/r))rrr/r)rrr/rrJr r7r r/r r)"rFrGrHrI __slots__rrrr rrrrrrrrrrrrrrrrrrrrrr classmethodrrr3r3r3r5r)sZ A               5  r)cseZdZdZdZedZ      d2d3fdd Zd4fdd Z e fd5fd!d" Z e fd5fd#d$ Z e fd6fd&d' Z d7fd(d) Zd7fd*d+ Zd8fd-d. Zd9d0d1ZZS):r+zBA render context that captures template variable and filter names.)local_referencesall_referencesundefined_references root_contextrz^[\w_][\w_\-]*$Nrr[ror&rpryrnrzr{r>ru Optional[VariableCaptureContext]rsrqc sjtj|||||||dg|_g|_g|_g|_|}|jr0t|jtr0|j}|jr0t|jts$||_ dS)Nr) superrrrr rrurRr+r ) r4rorprnr{rursrqr rr3r5rus,   zVariableCaptureContext.__init__r7r8rr r/rcs|jj|t||Sr)r rrr rrr r3r5rszVariableCaptureContext.assignrrrr.ct||}||||Sr)r r_count_referencer4rrresultr r3r5r zVariableCaptureContext.getcs&t||IdH}||||Sr)r rrrr r3r5rs z VariableCaptureContext.get_asyncrcrr)r rr)r4rrrr r3r5rrzVariableCaptureContext.resolvec|jj|t|Sr)r rrr rrr r3r5r z VariableCaptureContext.incrementcrr)r rrr rrr r3r5rrz VariableCaptureContext.decrementrcrr)r rrr rrr r3r5rrzVariableCaptureContext.filterrcCst|tr|}nrre_identmatchrr%r r r)r4rrref_pathelemr3r3r5rs    z'VariableCaptureContext._count_reference)NNrNr[r)ror&rpryrnrzr{r>rur rsr>rqr>rrrrr)rrrr.r/r)rFrGrHrIrrecompilerrrr rrrrrrr __classcell__r3r3r r5r+gs& r+csBeZdZdZedfdd Zedfd d ZdddZZS) FutureContextamA render context configured for maximum compatibility with the Ruby liquid. These "fixes" have not been implemented in the default `Context` for the benefit of existing Python Liquid users that rely on past behavior. This render context currently fixes https://github.com/jg-rp/liquid/issues/43 and https://github.com/jg-rp/liquid/issues/90. rJr r7r/cs*t|trt|trtdt||SNzstring indices are not allowed)rRr8r>rPr rrr r3r5rszFutureContext.getitemr.cs2t|trt|trtdt||IdHSr)rRr8r>rPr rrr r3r5rszFutureContext.getitem_asyncrr8rrcCsn|r|nt|}|jd}||d}z||}Wn ty$d}Ynw|d7}|t|kr1d}|||<|S)Nrrr[)r8rw setdefaultrPrV)r4rrr7rrrvr3r3r5rs     zFutureContext.cyclerrr) rFrGrHrIrrrrrr3r3r r5rs rc@seZdZdZdS)FutureVariableCaptureContextzIA context that captures information about template variables and filters.N)rFrGrHrIr3r3r3r5r"sr"r Sequence[Any]r`rOptional[object]c Gs4z ttj||}W|Stttfy|}Y|Sw)zChained item getter.)rr)rr<rPrQ)rJrr`itmr3r3r5r*sr*)rJr rKrLr/r.)rJr rKrgr/r.)rJr#r`r rr$r/r )OrI __future__rcollections.abcrSr:r^rrr contextlibr functoolsrriorroperatorrr typingr r r r rrrrrrrrrliquidrliquid.chain_maprliquid.exceptionsrrrrrr liquid.outputrliquid.undefinedr r!r"r#r$r%r&liquid.builtin.tags.for_tagr'liquid.templater(__all__r8r>rr.rr,rrXrarfrhrirjr)r+rr"r*r3r3r3r5s                                            <b(