3 ՛gYm@s@dZddlmZmZmZddlmZddlZGdddeZ Gddde Z Gd d d eZ e Z d ZGd d d eZGdddeZGdddeZGdddeZGdddeZGdddeZddZddZddZddZd d!Zd"d#Zd$d%Zd5d&d'Zd6d)d*Zd+d,Zd-d.Zd/d0Z d7d1d2Z!d3d4Z"dS)8zdprovides runtime services for templates, including Context, Namespace, and various helper functions.) exceptionsutilcompat)compat_builtinsNc@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|_||_|j|_d|_d|_i|_tjt ||jd<t |_ |jd<dS)Ncapturecaller) _buffer_stack_datacopy_kwargs_with_template_outputting_as_unicode namespacesrpartialr CallerStack caller_stack)selfbufferdatar./usr/lib/python3/dist-packages/mako/runtime.py__init__s zContext.__init__cCs0||_|jj|j}|r,tjddj|dS)Nz%Reserved words passed to render(): %sz, )r Zreserved_names intersectionr rZNameConflictErrorjoin)rtZ illegal_namesrrr_set_with_template*s zContext._set_with_templatecCs|jjS)z]Return the :class:`.TemplateLookup` associated with this :class:`.Context`. )r lookup)rrrrr2szContext.lookupcCs |jjS)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 )rrrrkwargs:szContext.kwargscCs|jj|dS)zQPush a ``caller`` callable onto the callstack for this :class:`.Context`.N)rappend)rrrrr push_callerPszContext.push_callercCs |jd=dS)zPPop a ``caller`` callable onto the callstack for this :class:`.Context`.N)r)rrrr pop_callerVszContext.pop_callercCst|jjS)zAReturn a list of all names established in this :class:`.Context`.)listr keys)rrrrr%\sz Context.keyscCs"||jkr|j|Stj|SdS)N)r r__dict__)rkeyrrr __getitem__as  zContext.__getitem__cCstj}|jj||jS)zUpush a capturing buffer onto this Context and return the new writer function.)rFastEncodingBufferr rwrite)rbufrrr _push_writergs zContext._push_writercCs|jj}||jdjfS)zupop the most recent capturing buffer from this Context and return the current writer after the pop. r!r")r popr*)rr+rrr_pop_buffer_and_writeros zContext._pop_buffer_and_writercCs |jdS)z*push a capturing buffer onto this Context.N)r,)rrrr _push_bufferxszContext._push_buffercCs |jjS)z7pop the most recent capturing buffer from this Context.)r r-)rrrr _pop_buffer}szContext._pop_bufferNcCs|jj|tjj||S)z+Return a value from this :class:`.Context`.)r getrr&)rr'defaultrrrr1sz Context.getcCs|jdj|dS)zSWrite a string to this :class:`.Context` object's underlying output buffer.r!Nr")r r*)rstringrrrr*sz Context.writecCs |jdjS)z#Return the current writer function.r!r")r r*)rrrrwriterszContext.writercCsJtjt}|j|_|jj|_|j|_|j|_|j|_|j|_|j |_ |S)N) r__new__r r r r r rrr)rcrrr_copys  z Context._copycCs |s|S|j}|jj||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. )r7r update)rdr6rrr_localss  zContext._localscCs6|j}|j}|jdd|jdd|jdd|S)zfcreate a new copy of this :class:`.Context`. with tokens related to inheritance state removed.rNparentnext)r7r r-)rr6xrrr_clean_inheritance_tokenss    z!Context._clean_inheritance_tokens)N)__name__ __module__ __qualname____doc__rrpropertyrrr r#r%r(r,r.r/r0r1r*r4r7r:r>rrrrrs&     rc@sDeZdZddZddZddZddZd d Zd d Zd dZ dS)rcCs d|_dS)N) nextcaller)rrrrrszCallerStack.__init__cCs|jS)N)__bool__)rrrr __nonzero__szCallerStack.__nonzero__cCst|r|jrdpdS)NTF)len _get_caller)rrrrrEszCallerStack.__bool__cCs|dS)Nr!r"r)rrrrrHszCallerStack._get_callercCst|j|S)N)getattrrH)rr'rrr __getattr__szCallerStack.__getattr__cCs|jpd}|j|d|_|S)N)rDr)rframerrr _push_frames  zCallerStack._push_framecCs|j|_dS)N)r-rD)rrrr _pop_frameszCallerStack._pop_frameN) r?r@rArrFrErHrJrLrMrrrrrsrc@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. cCs tddS)NrN) NameError)rrrr__str__szUndefined.__str__cCs|jS)N)rE)rrrrrFszUndefined.__nonzero__cCsdS)NFr)rrrrrEszUndefined.__bool__N)r?r@rArBrPrFrErrrrrNsrNc@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|_dS)N)stack)rrrrrszLoopStack.__init__cCs|j||jS)N)_push_top)riterablerrr_enters zLoopStack._entercCs|j|jS)N)_poprU)rrrr_exitszLoopStack._exitcCs|jr|jdS|SdS)Nr!r")rS)rrrrrUs zLoopStack._topcCs |jjS)N)rSr-)rrrrrXszLoopStack._popcCs&t|}|jr|jd|_|jj|S)Nr!r") LoopContextrSr;r)rrVnewrrrrT s zLoopStack._pushcCstjddS)NzNo loop context is established)rRuntimeException)rr'rrrrJszLoopStack.__getattr__cCs t|jS)N)iterrU)rrrr__iter__szLoopStack.__iter__N) r?r@rArBrrWrYrCrUrXrTrJr^rrrrrRs rRc@sreZdZdZddZddZejddZe dd Z e d d Z e d d Z e ddZ e ddZddZdS)rZaA 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|_dS)Nr) _iterableindexr;)rrVrrrr.szLoopContext.__init__ccs(x"|jD]}|V|jd7_qWdS)Nr!)r_r`)rirrrr^3s zLoopContext.__iter__cCs t|jS)N)rGr_)rrrr__len__8szLoopContext.__len__cCst||jdS)Nr!)rGr`)rrrr reverse_index<szLoopContext.reverse_indexcCs |jdkS)Nr)r`)rrrrfirst@szLoopContext.firstcCs|jt|dkS)Nr!)r`rG)rrrrlastDszLoopContext.lastcCs|j S)N)odd)rrrrevenHszLoopContext.evencCst|jdS)N)boolr`)rrrrrfLszLoopContext.oddcGs|s td||jt|S)z5Cycle through values as the loop progresses. z(You must provide values to cycle through) ValueErrorr`rG)rvaluesrrrcyclePszLoopContext.cycleN)r?r@rArBrr^rZmemoized_instancemethodrbrCrcrdrergrfrlrrrrrZs     rZc@seZdZddZddZdS)_NSAttrcCs ||_dS)N)_NSAttr__parent)rr;rrrrZsz_NSAttr.__init__cCs:|j}x&|r,t|j|r$t|j|S|j}qWt|dS)N)rnhasattrmodulerIinheritsAttributeError)rr'nsrrrrJ]s    z_NSAttr.__getattr__N)r?r@rArrJrrrrrmXsrmc@seZdZdZdddZfZdZdZdZdZ dZ dZ e j ddZdd Zd d Zd d ZeddZddZddZddZddZdS) 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||_||_||_|dk r.tdd|D|_dS)NcSsg|]}|j|fqSr)r?).0r6rrr sz&Namespace.__init__..)namecontextrqdict callables)rrwrxrzrq populate_self calling_urirrrrxs zNamespace.__init__cCst|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` )rm)rrrrattrszNamespace.attrcCsL||f}||jjkr |jj|St||jj||jd}||jj|<|SdS)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|N)rxrTemplateNamespacer7 _templateuri)rurir'rsrrr 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_templaterxr)rrrrr get_templateszNamespace.get_templatecKs|jj|f|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>``. )cacher1)rr'rrrr get_cacheds zNamespace.get_cachedcCs|jjS)zReturn the :class:`.Cache` object referenced by this :class:`.Namespace` object's :class:`.Template`. )templater)rrrrrszNamespace.cachecKst|j||jf|dS)z$Include a file at the given ``uri``.N) _include_filerxr)rrrrrr include_fileszNamespace.include_filecCsHxB|D]:}|dkr2x,|jD]\}}|||<qWqt||||<qWdS)N*) _get_starrI)rr9lZidentkvrrr _populates  zNamespace._populateccs*|jr&x|jD]}||j|fVqWdS)N)rz)rr'rrrrs zNamespace._get_starcCsL||jkr|j|}n&|jr*t|j|}ntd|j|ft||||S)Nz!Namespace '%s' has no member '%s')rzrqrIrrrwsetattr)rr'valrrrrJs   zNamespace.__getattr__)NNTN)r?r@rArBrrzrprrxfilenamerrrZmemoized_propertyr}rrrrCrrrrrJrrrrrtgs&       rtc@sNeZdZdZdddZeddZedd Zed d Zd d Z ddZ dS)rz@A :class:`.Namespace` specific to a :class:`.Template` instance.NTc Cs||_||_||_|dk r.tdd|D|_|dk rRt||||_|jjj|_ n"|dk rl||_|jj|_ nt d|rt ||j|d\} } dS)NcSsg|]}|j|fqSr)r?)rur6rrrrv,sz.TemplateNamespace.__init__..z 'template' argument is required.)self_ns) rwrxrqryrzrrrpZ _template_urir TypeError_populate_self_namespace) rrwrxrr~rzrqr{r|Z lclcallable lclcontextrrrr%s  zTemplateNamespace.__init__cCs|jjS)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. )rrp)rrrrrp=s zTemplateNamespace.modulecCs|jjS)zhThe path of the filesystem file used for this :class:`.Namespace`'s module or template. )rr)rrrrrHszTemplateNamespace.filenamecCs|jjS)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`. )rr)rrrrrOs zTemplateNamespace.uric#sXjr&xjD]}|j|fVqWfdd}x jjjD]}|||fVq>WdS)Ncsjj|}tj|jS)N)r_get_def_callablerrrx)r' callable_)rrrr1_s z(TemplateNamespace._get_star..get)rzrrpZ_exports)rr'r1rr)rrrZs   zTemplateNamespace._get_starcCst||jkr|j|}nN|jj|r>|jj|}tj||j}n&|jrRt|j|}nt d|j |ft ||||S)Nz!Namespace '%s' has no member '%s') rzrZhas_defrrrrxrqrIrrrwr)rr'rrrrrrJes     zTemplateNamespace.__getattr__)NNNNTN) r?r@rArBrrCrprrrrJrrrrr!s    rc@s6eZdZdZd ddZeddZdd Zd d ZdS) ModuleNamespacez;A :class:`.Namespace` specific to a Python module instance.NTc Csf||_||_||_|dk r.tdd|D|_t|}x$|jdddD]} t|| }qJW||_dS)NcSsg|]}|j|fqSr)r?)rur6rrrrvsz,ModuleNamespace.__init__...r!) rwrxrqryrz __import__splitrIrp) rrwrxrprzrqr{r|modtokenrrrrzszModuleNamespace.__init__cCs|jjS)zhThe path of the filesystem file used for this :class:`.Namespace`'s module or template. )rp__file__)rrrrrszModuleNamespace.filenameccst|jr&x|jD]}||j|fVqWxHt|jD]:}|ddkr2t|j|}tj|r2|tj||jfVq2WdS)Nr_)rzdirrprIrcallablerrx)rr'rrrrrs    zModuleNamespace._get_starcCst||jkr|j|}nNt|j|r>t|j|}tj||j}n&|jrRt|j|}ntd|j |ft ||||S)Nz!Namespace '%s' has no member '%s') rzrorprIrrrxrqrrrwr)rr'rrrrrrJs     zModuleNamespace.__getattr__)NNTN) r?r@rArBrrCrrrJrrrrrvs   rcsfdd}|S)zApply a caller_stack compatibility decorator to a plain Python function. See the example in :ref:`namespaces_python_modules`. c s,|jjz|f||S|jjXdS)N)rrLrM)rxargsr)funcrrwrap_stackframes z(supports_caller..wrap_stackframer)rrr)rrsupports_callers rc Os>tj|stjd|jz|||Wd|j}X|jS)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))N)rrrr\r/r0getvalue)rxrrrr+rrrrs  rcsfdd}|S)Ncsfdd}|S)Nc sLfdd}yjdd|_Wntk r6YnX|f||S)Ncsf||S)Nr)rkw)rx render_fnrryszB_decorate_toplevel..decorate_render..go..y)r?r)rxrrr)fnr)rxrgos z7_decorate_toplevel..decorate_render..gor)rr)r)rrdecorate_renders z+_decorate_toplevel..decorate_renderr)rrr)rr_decorate_toplevels rcsfdd}|S)Ncs|fdd}|S)Ncsf||S)Nr)rr)rxdecrrrsz5_decorate_inline..decorate_render..gor)rr)rxr)rrrsz)_decorate_inline..decorate_renderr)rxrrr)rxrr_decorate_inlinesrc Kst|||}t|j|\}}t||jf|}|jr~y||f|Wqtk rz|j|tj}|svtj t j YqXn ||f|dS)zPlocate the template from the given uri and include it in the current output.N) rrr>_kwargs_for_includer Zinclude_error_handler Exceptionr exception_asreraisesysexc_info)rxrr|rrrZctxresultrrrrs  rc Cs|dkr dSt|||}|d}|}x|jdk r8|j}q&W|jd|i}td|j||dd|_|j|jd<|jd<t|jd d}|dk r|||}|r|St|jd d} | dk r| ||j|fS) zcalled by the _inherit method in template modules to set up the inheritance chain at the start of a template's execution.Nrr<zself:%sF)rr{r;local _mako_inheritZ_mako_generate_namespaces) rrqr:rrr rIrpr) rxrr|rrZihrrretZgen_nsrrr _inherit_froms,      rc Csf|jj}|dkr"tjd|jj|j||}y |j|Stjk r`tjtt j YnXdS)Nz.Template '%s' has no TemplateLookup associated) r rrZTemplateLookupExceptionrZ adjust_urirZTopLevelLookupExceptionstrrr)rxrZ relativetorrrrrs   rcCs^|dkrtd|j||dd}||jd<|jd<t|jdrT|jj||}|rT|S|j|fS)Nzself:%sF)rr{rrr)rrr rorprr)rxrrrrrrr's  rFcCsx|rtjdd}n$|jr"tj}ntj||j|jd}t|f|}||_|j |t |||f|t |||j j S)z^create a Context and return the string output of the given template and template callable.T) as_unicode)rencodingerrors)rr)Zbytestring_passthroughrStringIOoutput_encodingencoding_errorsrrr_render_context_kwargs_for_callabler0r)rrrrrr+rxrrr_render4s     rcCsntj|}|dr|S|ddd|ddD}i}x0|D](}|dkr>||kr>||kr>||||<q>W|S)NrhrcSsg|]}|dk r|qS)Nr)rurrrrrvQsz(_kwargs_for_callable..r!rx)rinspect_func_args)rrargspec namedargsrargrrrrJs  rcKs^tj|}|ddd|ddD}x0|D](}|dkr.||kr.||kr.||||<q.W|S)NrcSsg|]}|dk r|qS)Nr)rurrrrrv[sz'_kwargs_for_include..r!rrx)rr)rrrrrrrrrrYs   rcOsZddlj}t||js6t||\}}t||||dn t||j\}}t||||ddS)Nr)rr)Z mako.templater isinstanceZ DefTemplater_exec_templater;)ZtmplrrxrrrZinheritrrrrrbs   rc Cs|j}|dk rx|js|jrxy||f||Wqtk rRt||tjYqtjd}t|||YqXn||f||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 Zformat_exceptions error_handlerr _render_errorrrrr)rrxrrrerrrrps  rcCs|jr&|j||}|stjtjn\tj}|jrNtj ddg|j dd<ntj |j |j g|j dd<|j ||j||ddS)NT)r)error)rrrrrrZhtml_error_templaterrr)r rrrZrender_context)rrxrrZerror_templaterrrrs  r)N)F)NN)#rBZmakorrrZ mako.compatrrobjectrr$rrNZ UNDEFINEDZSTOP_RENDERINGrRrZrmrtrrrrrrrrrrrrrrrrrrrrs< ,(B;U3