o gl@sHdZddlZddlZddlZddlmZddlmZddlmZGdddZGdd d e Z Gd d d Z e Z d Z Gd ddZGdddZGdddZGdddZGdddeZGdddeZddZddZddZdd Zd!d"Zd#d$Zd%d&Zd6d'd(Zd7d*d+Zd,d-Zd.d/Zd0d1Zd8d2d3Z d4d5Z!dS)9zdprovides runtime services for templates, including Context, Namespace, and various helper functions.N)compat) exceptions)utilc@seZdZdZddZddZeddZedd Zd d Z d d Z ddZ ddZ ddZ ddZddZddZd'ddZddZdd Zd!d"Zd#d$Zd%d&ZdS)(ContextzProvides runtime namespace, output buffer, and various callstacks for templates. See :ref:`runtime_toplevel` for detail on the usage of :class:`.Context`. cKsR|g|_||_||_d|_d|_i|_tt ||jd<t |_ |jd<dS)Ncapturecaller) _buffer_stack_datacopy_kwargs_with_template_outputting_as_unicode namespaces functoolspartialr CallerStack caller_stack)selfbufferdatarH/var/www/html/flaskapp/venv/lib/python3.10/site-packages/mako/runtime.py__init__s zContext.__init__cCs0||_|j|j}|rtdd|dS)Nz%Reserved words passed to render(): %sz, )r reserved_names intersectionr rNameConflictErrorjoin)rt illegal_namesrrr_set_with_template.szContext._set_with_templatecC|jjS)z]Return the :class:`.TemplateLookup` associated with this :class:`.Context`. )r lookuprrrrr!7szContext.lookupcC |jS)a]Return the dictionary of top level keyword arguments associated with this :class:`.Context`. This dictionary only includes the top-level arguments passed to :meth:`.Template.render`. It does not include names produced within the template execution such as local variable names or special names such as ``self``, ``next``, etc. The purpose of this dictionary is primarily for the case that a :class:`.Template` accepts arguments via its ``<%page>`` tag, which are normally expected to be passed via :meth:`.Template.render`, except the template is being called in an inheritance context, using the ``body()`` method. :attr:`.Context.kwargs` can then be used to propagate these arguments to the inheriting template:: ${next.body(**context.kwargs)} )r r r"rrrkwargs?s zContext.kwargscCs|j|dS)zQPush a ``caller`` callable onto the callstack for this :class:`.Context`.N)rappend)rrrrr push_callerUszContext.push_callercCs |jd=dS)zPPop a ``caller`` callable onto the callstack for this :class:`.Context`.N)rr"rrr pop_caller[s zContext.pop_callercCst|jS)zAReturn a list of all names established in this :class:`.Context`.)listr keysr"rrrr*asz Context.keyscCs||jvr |j|Stj|SN)r builtins__dict__rkeyrrr __getitem__fs   zContext.__getitem__cCst}|j||jS)zUpush a capturing buffer onto this Context and return the new writer function.)rFastEncodingBufferrr%writerbufrrr _push_writerls zContext._push_writercCs|j}||jdjfS)zupop the most recent capturing buffer from this Context and return the current writer after the pop. r')rpopr2r3rrr_pop_buffer_and_writerts zContext._pop_buffer_and_writercCs |dS)z*push a capturing buffer onto this Context.N)r5r"rrr _push_buffer} zContext._push_buffercCr#)z7pop the most recent capturing buffer from this Context.)rr6r"rrr _pop_buffers zContext._pop_bufferNcCs|j|tj||S)z+Return a value from this :class:`.Context`.)r getr,r-)rr/defaultrrrr;sz Context.getcCs|jd|dS)zSWrite a string to this :class:`.Context` object's underlying output buffer.r'Nrr2)rstringrrrr2sz Context.writecCs |jdjS)z#Return the current writer function.r'r=r"rrrwriterr9zContext.writercCsJtt}|j|_|j|_|j|_|j|_|j|_|j|_|j |_ |Sr+) r__new__rr r r r r rr)rcrrr_copys  z Context._copycCs |s|S|}|j||S)zCreate a new :class:`.Context` with a copy of this :class:`.Context`'s current state, updated with the given dictionary. The :attr:`.Context.kwargs` collection remains unaffected. )rBr update)rdrArrr_localss   zContext._localscCs6|}|j}|dd|dd|dd|S)zfcreate a new copy of this :class:`.Context`. with tokens related to inheritance state removed.rNparentnext)rBr r6)rrAxrrr_clean_inheritance_tokenss    z!Context._clean_inheritance_tokensr+)__name__ __module__ __qualname____doc__rrpropertyr!r$r&r(r*r0r5r7r8r:r;r2r?rBrErIrrrrrs,     rc@sDeZdZddZddZddZddZd d Zd d Zd dZ dS)rcCs d|_dSr+) nextcallerr"rrrr zCallerStack.__init__cC|Sr+__bool__r"rrr __nonzero__zCallerStack.__nonzero__cCst|r |r dp dS)NTF)len _get_callerr"rrrrSszCallerStack.__bool__cCs|dSNr'rr"rrrrWszCallerStack._get_callercCst||Sr+)getattrrWr.rrr __getattr__zCallerStack.__getattr__cCs|jpd}||d|_|Sr+)rOr%)rframerrr _push_frames  zCallerStack._push_framecCs||_dSr+)r6rOr"rrr _pop_framer[zCallerStack._pop_frameN) rJrKrLrrTrSrWrZr]r^rrrrrs rc@s(eZdZdZddZddZddZdS) UndefinedzRepresents an undefined value in a template. All template modules have a constant value ``UNDEFINED`` present which is an instance of this object. cCstd)Nr_) NameErrorr"rrr__str__rUzUndefined.__str__cCrQr+rRr"rrrrTrUzUndefined.__nonzero__cCsdS)NFrr"rrrrSszUndefined.__bool__N)rJrKrLrMrarTrSrrrrr_s  r_c@sTeZdZdZddZddZddZedd Zd d Z d d Z ddZ ddZ dS) LoopStackza stack for LoopContexts that implements the context manager protocol to automatically pop off the top of the stack on context exit cCs g|_dSr+stackr"rrrrrPzLoopStack.__init__cCs|||jSr+)_push_topriterablerrr_enters zLoopStack._entercCs||jSr+)_poprgr"rrr_exitszLoopStack._exitcCs|jr|jdS|SrXrdr"rrrrgs zLoopStack._topcCr#r+)rer6r"rrrrk rPzLoopStack._popcCs&t|}|jr |jd|_|j|SrX) LoopContextrerFr%)rrinewrrrrfs  zLoopStack._pushcCs td)NzNo loop context is established)rRuntimeExceptionr.rrrrZrPzLoopStack.__getattr__cC t|jSr+)iterrgr"rrr__iter__rPzLoopStack.__iter__N) rJrKrLrMrrjrlrNrgrkrfrZrrrrrrrcs  rcc@sreZdZdZddZddZejddZe dd Z e d d Z e d d Z e ddZ e ddZddZdS)rmaA magic loop variable. Automatically accessible in any ``% for`` block. See the section :ref:`loop_context` for usage notes. :attr:`parent` -> :class:`.LoopContext` or ``None`` The parent loop, if one exists. :attr:`index` -> `int` The 0-based iteration count. :attr:`reverse_index` -> `int` The number of iterations remaining. :attr:`first` -> `bool` ``True`` on the first iteration, ``False`` otherwise. :attr:`last` -> `bool` ``True`` on the last iteration, ``False`` otherwise. :attr:`even` -> `bool` ``True`` when ``index`` is even. :attr:`odd` -> `bool` ``True`` when ``index`` is odd. cCs||_d|_d|_dSNr) _iterableindexrFrhrrrr3s zLoopContext.__init__ccs&|jD] }|V|jd7_qdSN)rtru)rirrrrr8s  zLoopContext.__iter__cCrpr+)rVrtr"rrr__len__= zLoopContext.__len__cCst||jdSrv)rVrur"rrr reverse_indexAzLoopContext.reverse_indexcCs |jdkSrs)rur"rrrfirstErzzLoopContext.firstcCs|jt|dkSrv)rurVr"rrrlastIr|zLoopContext.lastcCs|j Sr+)oddr"rrrevenMszLoopContext.evencCst|jdS)N)boolrur"rrrrQszLoopContext.oddcGs|std||jt|S)z,Cycle through values as the loop progresses.z(You must provide values to cycle through) ValueErrorrurV)rvaluesrrrcycleUszLoopContext.cycleN)rJrKrLrMrrrrmemoized_instancemethodryrNr{r}r~rrrrrrrrms"       rmc@seZdZddZddZdS)_NSAttrcCs ||_dSr+)_NSAttr__parent)rrFrrrr]rPz_NSAttr.__init__cCs4|j}|rt|j|rt|j|S|j}|st|r+)rhasattrmodulerYinheritsAttributeError)rr/nsrrrrZ`s  z_NSAttr.__getattr__N)rJrKrLrrZrrrrr\s rc@seZdZdZ    dddZdZdZ dZ dZ dZ dZ dZ e j ddZd d Zd d Zd dZeddZddZddZddZddZdS) NamespaceaProvides access to collections of rendering methods, which can be local, from other templates, or from imported modules. To access a particular rendering method referenced by a :class:`.Namespace`, use plain attribute access: .. sourcecode:: mako ${some_namespace.foo(x, y, z)} :class:`.Namespace` also contains several built-in attributes described here. NTcCs2||_||_||_|durdd|D|_dSdS)NcSi|]}|j|qSrrJ.0rArrr z&Namespace.__init__..)namecontextr callables)rrrrr populate_self calling_urirrrr{s  zNamespace.__init__rcCst|S)a-Access module level attributes by name. This accessor allows templates to supply "scalar" attributes which are particularly handy in inheritance relationships. .. seealso:: :ref:`inheritance_attr` :ref:`namespace_attr_for_includes` )rr"rrrattrszNamespace.attrcCsH||f}||jjvr|jj|St||j||jd}||jj|<|S)a]Return a :class:`.Namespace` corresponding to the given ``uri``. If the given ``uri`` is a relative URI (i.e. it does not contain a leading slash ``/``), the ``uri`` is adjusted to be relative to the ``uri`` of the namespace itself. This method is therefore mostly useful off of the built-in ``local`` namespace, described in :ref:`namespace_local`. In most cases, a template wouldn't need this function, and should instead use the ``<%namespace>`` tag to load namespaces. However, since all ``<%namespace>`` tags are evaluated before the body of a template ever runs, this method can be used to locate namespaces using expressions that were generated within the body code of the template, or to conditionally use a particular namespace. ) templateurir)rrTemplateNamespacerB _templateuri)rurir/rrrr get_namespaces   zNamespace.get_namespacecCst|j||jS)zReturn a :class:`.Template` from the given ``uri``. The ``uri`` resolution is relative to the ``uri`` of this :class:`.Namespace` object's :class:`.Template`. )_lookup_templaterr)rrrrr get_templateszNamespace.get_templatecKs|jj|fi|S)aReturn a value from the :class:`.Cache` referenced by this :class:`.Namespace` object's :class:`.Template`. The advantage to this method versus direct access to the :class:`.Cache` is that the configuration parameters declared in ``<%page>`` take effect here, thereby calling up the same configured backend as that configured by ``<%page>``. )cacher;)rr/r$rrr get_cacheds zNamespace.get_cachedcCr )zReturn the :class:`.Cache` object referenced by this :class:`.Namespace` object's :class:`.Template`. )templaterr"rrrrszNamespace.cachecKst|j||jfi|dS)z$Include a file at the given ``uri``.N) _include_filerr)rrr$rrr include_file szNamespace.include_filecCs@|D]}|dkr|D]\}}|||<q qt||||<qdS)N*) _get_starrY)rrDlidentkvrrr _populates zNamespace._populateccs,|jr|jD] }||j|fVqdSdSr+)rr.rrrrs  zNamespace._get_starcCsL||jvr |j|}n|jrt|j|}n td|j|ft||||SNz!Namespace '%s' has no member '%s')rrrYrrsetattr)rr/valrrrrZs    zNamespace.__getattr__NNTN)rJrKrLrMrrrrrfilenamerrrmemoized_propertyrrrrrNrrrrrZrrrrrjs<        rc@sZeZdZdZ      dddZeddZedd Zed d Zd d Z ddZ dS)rz@A :class:`.Namespace` specific to a :class:`.Template` instance.NTc Cs||_||_||_|durdd|D|_|dur't||||_|jjj|_n|dur4||_|jj|_nt d|rFt ||j|d\} } dSdS)NcSrrrrrrrr?rz.TemplateNamespace.__init__..z 'template' argument is required.)self_ns) rrrrrrr _template_urir TypeError_populate_self_namespace) rrrrrrrrr lclcallable lclcontextrrrr0s"  zTemplateNamespace.__init__cCr )zThe Python module referenced by this :class:`.Namespace`. If the namespace references a :class:`.Template`, then this module is the equivalent of ``template.module``, i.e. the generated module for the template. )rrr"rrrrO zTemplateNamespace.modulecCr zhThe path of the filesystem file used for this :class:`.Namespace`'s module or template. )rrr"rrrrZzTemplateNamespace.filenamecCr )zThe URI for this :class:`.Namespace`'s template. I.e. whatever was sent to :meth:`.TemplateLookup.get_template()`. This is the equivalent of :attr:`.Template.uri`. )rrr"rrrrarzTemplateNamespace.uric#sRjrjD] }|j|fVqfdd}jjjD] }|||fVqdS)Ncsj|}t|jSr+)r_get_def_callablerrr)r/ callable_r"rrr;qs z(TemplateNamespace._get_star..get)rrr_exports)rr/r;rrr"rrls  zTemplateNamespace._get_starcCst||jvr |j|}n'|j|r|j|}t||j}n|jr)t|j|}n t d|j |ft ||||Sr) rrhas_defrrrrrrYrrrrr/rrrrrrZxs      zTemplateNamespace.__getattr__)NNNNTN) rJrKrLrMrrNrrrrrZrrrrr,s"     rc@s>eZdZdZ    d ddZeddZdd Zd d ZdS) ModuleNamespacez;A :class:`.Namespace` specific to a Python module instance.NTc Cs^||_||_||_|durdd|D|_t|}|dddD]} t|| }q"||_dS)NcSrrrrrrrrrz,ModuleNamespace.__init__...rw)rrrr __import__splitrYr) rrrrrrrrmodtokenrrrrs   zModuleNamespace.__init__cCr r)r__file__r"rrrrrzModuleNamespace.filenameccsl|jr|jD] }||j|fVqt|jD]}|ddkr3t|j|}t|r3|t||jfVqdS)Nr_)rdirrrYcallablerrr)rr/rrrrrs   zModuleNamespace._get_starcCst||jvr |j|}n't|j|rt|j|}t||j}n|jr)t|j|}n td|j |ft ||||Sr) rrrrYrrrrrrrrrrrrZs      zModuleNamespace.__getattr__r) rJrKrLrMrrNrrrZrrrrrs   rcfdd}|S)zApply a caller_stack compatibility decorator to a plain Python function. See the example in :ref:`namespaces_python_modules`. cs:|jz|g|Ri|W|jS|jwr+)rr]r^)rargsr$funcrrwrap_stackframes z(supports_caller..wrap_stackframer)rrrrrsupports_callers rcOsFt|s td|z||i|W|}|S|}w)zExecute the given template def, capturing the output into a buffer. See the example in :ref:`namespaces_python_modules`. z[capture() function expects a callable as its argument (i.e. capture(func, *args, **kwargs)))rrror8r:getvalue)rrrr$r4rrrrs rcr)Ncsfdd}|S)NcsPfdd}z jdd|_Wn tyYnw|g|Ri|S)Ncg|Ri|Sr+rrkw)r render_fnrryzB_decorate_toplevel..decorate_render..go..y)rJr)rrrr)fnr)rrgos z7_decorate_toplevel..decorate_render..gorrrr)rrdecorate_renders z+_decorate_toplevel..decorate_renderr)rrrrr_decorate_toplevels rcsfdd}|S)Ncs|fdd}|S)Ncrr+rr)rdecrrrrz5_decorate_inline..decorate_render..gorrrr)rrrsz)_decorate_inline..decorate_renderr)rrrrrr_decorate_inlinesrcKst|||}t||\}}t||jfi|}|jr=z ||fi|WdSty<||t}|s9YdSw||fi|dS)zPlocate the template from the given uri and include it in the current output.N) rrrI_kwargs_for_includer include_error_handler Exceptionr exception_as)rrrr$rrctxresultrrrrs  rc Cs|durdSt|||}|d}|}|jdur|j}|jdus|d|i}td|j||dd|_|j|jd<|jd<t|jd d}|durQ|||}|rQ|St|jd d} | dur`| ||j|fS) zcalled by the _inherit method in template modules to set up the inheritance chain at the start of a template's execution.NrrGself:%sFrrrFlocal _mako_inherit_mako_generate_namespaces) rrrErrr rYrr) rrrrrihrrretgen_nsrrr _inherit_froms2     rc Csj|jj}|durtd|jj|||}z||WStjy4}z ttt |d}~ww)Nz.Template '%s' has no TemplateLookup associated) r r!rTemplateLookupExceptionr adjust_urirTopLevelLookupExceptionstrrr)rr relativetor!errrr<s$   rcCs^|durtd|j||dd}||jd<|jd<t|jdr*|j||}|r*|S|j|fS)NrFrrrr)rrr rrrr)rrrrrrrrLs  rFcCsl|rt}n tj|j|jd}t|fi|}||_||t|||g|Rit||| S)z^create a Context and return the string output of the given template and template callable.)encodingerrors) rr1output_encodingencoding_errorsrr r_render_context_kwargs_for_callabler:r)rrrr as_unicoder4rrrr_render\s$   rcCsjt|}|dr |S|ddd|ddD}i}|D]}|dkr2||vr2||vr2||||<q|S)NrrcSg|]}|dur|qSr+rrrrrr {z(_kwargs_for_callable..rwrrinspect_getargspec)rrargspec namedargsr$argrrrrts  rcKsZt|}|ddd|ddD}|D]}|dkr*||vr*||vr*||||<q|S)NrcSrr+rrrrrrrz'_kwargs_for_include..rwrrr)rrr$rrr rrrrs  rcOs^ddlm}t||jst||\}}t||||ddSt||j\}}t||||ddS)Nr)rr$) mako.templater isinstance DefTemplater_exec_templaterF)tmplrrrr$rinheritrrrrrs  rcCs|j}|dur?|js |jr?z||g|Ri|WdSty-t||tYdStd}t|||YdS||g|Ri|dS)zexecute a rendering callable given the callable, a Context, and optional explicit arguments the contextual Template will be located if it exists, and the error handling options specified on that Template will be interpreted here. Nr) r format_exceptions error_handlerr _render_errorrrsysexc_info)rrrr$rrrrrr s  r cCs|jr|||}|st\}}}|r|r|||dSt}|jr1tg|j dd<nt|j |j g|j dd<| ||j ||ddS)N)error)rrrwith_tracebackrhtml_error_templater rr1rrrrrender_context)rrrrtpvaluetberror_templaterrrrs$   rr+)F)NN)"rMr,rrmakorrrrr)rr_ UNDEFINEDSTOP_RENDERINGrcrmrrrrrrrrrrrrrrrrr rrrrrsD   -(AC]: