o .dB@sdZddlmZddlmZddlmZddlmZddlm Z ddl m Z ddl m Z dd l m Z dd l mZdd l mZdd l mZdd l mZddl mZddl mZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z ddl!m"Z"ddl!m#Z#ddl!m$Z$ddl!m%Z%ddl!m&Z&ddl!m'Z'e rdd l(m)Z)dd!l*m+Z+dd"l,m-Z-d#Z.Gd$d%d%Z/Gd&d'd'e/Z0Gd(d)d)e/Z1Gd*d+d+e0Z2Gd,d-d-ee3ee3fZ4d.S)/zLiquid template definition.) annotations)Counter)abc)StringIO)Path) TYPE_CHECKING)Any) Awaitable)Dict)Iterator)Mapping)Optional)TextIO)Union)Context) FutureContext)FutureVariableCaptureContext)ReadOnlyChainMap)VariableCaptureContext)Error)LiquidInterrupt)LiquidSyntaxError) StopRender)LimitedStringIO)ContextualTemplateAnalysis)NameRefsReferencedVariable)Refs)TemplateAnalysis)_TemplateCounter) Environment) ParseTree)UpToDate) AwareBoundTemplate BoundTemplaterFutureAwareBoundTemplateFutureBoundTemplaterrrr TemplateDropc@seZdZdZeZeZ     dFdGddZdHddZ dHddZ dIddZ ddd dJd)d*Z ddd dJd+d,Z edKd-d.ZdKd/d0ZdLd3d4ZdMd5d6ZdNd7d8Z 9dOdPd=d>Z 9dOdPd?d@ZdQdBdCZdQdDdEZdS)Rr%aA liquid template that has been parsed and is bound to a `liquid.Environment`. You probably don't want to instantiate `BoundTemplate` directly. Use `liquid.Environment.from_string` or `liquid.Environment.get_template` instead. Args: env: The environment this template is bound to. parse_tree: The parse tree representing this template. name: Optional name of the template. Defaults to an empty string. path: Optional origin path or identifier for the template. globals: An optional mapping of context variables made available every time the resulting template is rendered. Defaults to `None`. matter: Optional mapping containing variables associated with the template. Could be "front matter" or other meta data. uptodate: Optional callable that will return `True` if the template is up to date, or `False` if it needs to be reloaded. Defaults to `None`. Nenvr! parse_treer"namestrpathOptional[Union[str, Path]]globalsOptional[Dict[str, object]]matterOptional[Mapping[str, object]]uptodater#cCs6||_||_|p i|_|pi|_||_||_||_dSN)r*treer0r2r,r.r4)selfr*r+r,r.r0r2r4r8G/var/www/Matress/matenv/lib/python3.10/site-packages/liquid/template.py__init__Os    zBoundTemplate.__init__argsrkwargsreturncOs>|j|j|t|i||d}|}||||S)zRender the template with `args` and `kwargs` included in the render context. Accepts the same arguments as the `dict` constructor. r0template) context_classr* make_globalsdict _get_bufferrender_with_contextgetvaluer7r;r<contextbufr8r8r9renderas zBoundTemplate.rendercsF|j|j|t|i||d}|}|||IdH|S)z;An async version of `liquid.template.BoundTemplate.render`.r>N)r@r*rArBrCrender_with_context_asyncrErFr8r8r9 render_asyncoszBoundTemplate.render_asyncrcCs |jjdur tSt|jjdS)N)limit)r*output_stream_limitrrr7r8r8r9rCzs zBoundTemplate._get_bufferF)partial block_scoperGrbufferrrOboolrPNonec Os||t|i|}|j|dn|jjD]X}z|||WqtyI} z|r,|r>|jt d| d| j dnWYd} ~ qd} ~ wt yRYn%t yn} z|jj| | j dWYd} ~ qd} ~ wwWddSWddS1swYdS)a(Render the template using an existing context and output buffer. Args: context: A render context. buffer: File-like object to which rendered text is written. partial: If `True`, indicates that the current template has been included using either a "render" or "include" tag. Defaults to `False`. block_scope: If `True`, indicates that assigns, breaks and continues from this template will not leak into the parent context. Defaults to `False`. args: Passed to the `dict` constructor. The resulting dictionary is added to the render context. kwargs: Passed to the `dict` constructor. The resulting dictionary is added to the render context.  namespace unexpected ''linenumN)make_partial_namespacerBextendr6 statementsrIrr*errorrtokenrYrr r7rGrQrOrPr;r<rUnodeerrr8r8r9rDs2   ""z!BoundTemplate.render_with_contextc s||t|i|}|j|dq|jjD][}z |||IdHWqtyM} z|r0|rB|jt d| d| j dnWYd} ~ qd} ~ wt yVYn%t yr} z|jj| | j dWYd} ~ qd} ~ wwWddSWddS1swYdS)z*An async version of `render_with_context`.rTNrVrWrX)rZrBr[r6r\rKrr*r]rr^rYrrr_r8r8r9rJs4    ""z'BoundTemplate.render_with_context_asynccCs4|jsdS|}t|tstdt|j|S)z;`False` if the template has bee modified, `True` otherwise.Tz(expected a boolean from uptodate, found )r4 isinstancerRrtype__name__r7r4r8r8r9 is_up_to_dates zBoundTemplate.is_up_to_datecs,|jsdS|}t|tr|IdHS|S)zAn async version of the `is_up_to_date` property. If `template.uptodate` is a coroutine, it wil be awaited. Otherwise it will be called just like `is_up_to_date` TN)r4rbr rer8r8r9is_up_to_date_asyncs  z!BoundTemplate.is_up_to_date_async render_argsMapping[str, object]cCst||j|jS)zAReturn a mapping including render arguments and template globals.)rr2r0)r7rhr8r8r9rAs zBoundTemplate.make_globalscCsi|d|iS)zuReturn a namespace dictionary. This is used by `render_with_context` to extend an existing context. rOr8r7rOrhr8r8r9rZs z$BoundTemplate.make_partial_namespacecCsd|jd|jdS)NzTemplate(name='z ', path=''))r,r.rNr8r8r9__repr__szBoundTemplate.__repr__Tfollow_partialsraise_for_failuresrc Cspt|||d}tdd|jDdd|jDdd|jDt|jt|j t|j t|j dS)aStatically analyze this template and any included/rendered templates. Args: follow_partials: If `True`, we will try to load partial templates and analyze those templates too. raise_for_failures: If `True`, will raise an exception if an `ast.Node` or `expression.Expression` does not define a `children()` method, or if a partial template can not be loaded. When `False`, no exception is raised and a mapping of failed nodes and expressions is available as the `failed_visits` property. A mapping of unloadable partial templates is stored in the `unloadable_partials` property. rmrncSi|] \}}t||qSr8r.0kvr8r8r9 z)BoundTemplate.analyze..cSrpr8rrqr8r8r9rucSrpr8rrqr8r8r9ru"rw variableslocal_variablesglobal_variables failed_visitsunloadable_partialsfilterstags) r analyzerryitemstemplate_localstemplate_globalsrBr|r}r~rr7rmrnrefsr8r8r9rs(zBoundTemplate.analyzec sxt|||dIdH}tdd|jDdd|jDdd|jDt|jt|j t|j t|j dS)zAn async version of `analyze`.roNcSrpr8rrqr8r8r9ru6rvz/BoundTemplate.analyze_async..cSrpr8rrqr8r8r9ru7rwcSrpr8rrqr8r8r9ru:rwrx) r analyze_asyncrryrrrrBr|r}r~rrr8r8r9r+s*zBoundTemplate.analyze_asyncrcOsl|j|j|t|i|d}|}|||ttt|jtt|j tt|j tt|j dS)aAnalyze a path through this template's syntax tree given some context data. Unlike `analyze`, this form of template analysis does perform a render, capturing template variables as we go. Python Liquid does not currently support template introspection from within a render context or `Expression` object. Meaning line numbers and template names are not available. Only variable names are reported along with the number of times they were referenced. It's also, using this method, not currently possible to detect names added to a block's scope. For example, `forloop.index` will be included in the results object if referenced within a `for` loop block. Accepts the same arguments as `render`. r0 all_variablesrzundefined_variablesr~) capture_context_classr*rArBrCrDrrall_referenceslocal_referencesundefined_referencesr~rFr8r8r9analyze_with_contextCs     z"BoundTemplate.analyze_with_contextcst|j|j|t|i|d}|}|||IdHttt|jtt|j tt|j tt|j dS)z+An async version of `analyze_with_context`.rNr) rr*rArBrCrJrrrrrr~rFr8r8r9analyze_with_context_asyncbs    z(BoundTemplate.analyze_with_context_async)r)NNNN)r*r!r+r"r,r-r.r/r0r1r2r3r4r#)r;rr<rr=r-)r=r)rGrrQrr;rrOrRrPrRr<rr=rS)r=rR)rhrir=ri)rOrRrhrir=rir=r-)TT)rmrRrnrRr=r)r;rr<rr=r)rd __module__ __qualname____doc__rr@rrr:rIrKrCrDrJpropertyrfrgrArZrlrrrrr8r8r8r9r%7s>    8%     $ r%cs0eZdZdZdfdd Zdfdd ZZS)r$zIA `BoundTemplate` subclass with a `TemplateDrop` in the global namespace.r;rr<r=rScs&tj|i|t|j|j|_dSr5)superr:r(r,r.drop)r7r;r< __class__r8r9r:vszAwareBoundTemplate.__init__rOrRrhriabc.Mapping[str, object]csd|jit||S)Nr?)rrrZrjrr8r9rZzs z)AwareBoundTemplate.make_partial_namespace)r;rr<rr=rS)rOrRrhrir=r)rdrrrr:rZ __classcell__r8r8rr9r$ssr$c@eZdZdZeZeZdS)r'zrA `BoundTemplate` configured to use the `FutureContext` render context. See `liquid.future.Environment`. Nrdrrrrr@rrr8r8r8r9r'sr'c@r)r&zA `BoundTemplate` configured to use the `FutureContext` render context. Inserts a `TemplateDrop` into the global namespace automatically. See `liquid.future.Environment`. Nrr8r8r8r9r&sr&c@sVeZdZdZdddZdd d Zdd d ZdddZd ddZd!ddZ d"ddZ dS)#r(zTemplate meta data mapping.r,r-r.r/cCs~||_||_|jrt|jtrt|j|_|jj|_d|_d|jvr+|jdd|_|jjj|jjdd|jd|_ dS)N.r) directoryr,suffix) r,r.rbr-rstemrsplitparent_items)r7r,r.r8r8r9r:s    zTemplateDrop.__init__r=cCs|jSr5)rrNr8r8r9__str__szTemplateDrop.__str__cCs$d|dd|dd|ddS)NzTemplateDrop(directory='rz ', name='r,z ', suffix='rrkr8rNr8r8r9rls zTemplateDrop.__repr__itemobjectrRcCs ||jvSr5)r)r7rr8r8r9 __contains__ zTemplateDrop.__contains__key Optional[str]cCs|jt|Sr5)rr-)r7rr8r8r9 __getitem__szTemplateDrop.__getitem__intcC t|jSr5)lenrrNr8r8r9__len__rzTemplateDrop.__len__ Iterator[str]cCrr5)iterrrNr8r8r9__iter__rzTemplateDrop.__iter__N)r,r-r.r/r)rrr=rR)rrr=r)r=r)r=r) rdrrrr:rrlrrrrr8r8r8r9r(s      r(N)5r __future__r collectionsrriorpathlibrtypingrrr r r r r rrliquid.contextrrrrrliquid.exceptionsrrrr liquid.outputrliquid.static_analysisrrrrrr liquidr! liquid.astr"liquid.loadersr#__all__r%r$r'r&r-r(r8r8r8r9sV                                 >