/opt/cloudlinux/venv/lib/python3.11/site-packages/mako/__pycache__
Edit: /opt/cloudlinux/venv/lib/python3.11/site-packages/mako/__pycache__/template.cpython-311.pyc (27955B)
b2v ( d Z ddlZddlZddlZddlZddlZddlZddlZddlZddl m
Z
ddl m Z ddl m Z ddl m
Z
ddl mZ ddl mZ dd lmZ G d
d Z G d d
e Z G d de Z G d d Zd Zd Zd Zd Zd ZdS )zProvides the Template class, a facade for parsing, generating and executing
template strings, as well as template runtime operations. N)cache)codegen)compat)
exceptions)runtime)util)Lexerc N e Zd ZdZeZ ddZej d Z d
Z
d Z e d Z
e d
Zej d Ze d Ze d Ze d Zd Zd Zd Zd Zd Zd Zd Ze d ZdS )Templatea| Represents a compiled template.
:class:`.Template` includes a reference to the original
template source (via the :attr:`.source` attribute)
as well as the source code of the
generated Python module (i.e. the :attr:`.code` attribute),
as well as a reference to an actual Python module.
:class:`.Template` is constructed using either a literal string
representing the template text, or a filename representing a filesystem
path to a source file.
:param text: textual template source. This argument is mutually
exclusive versus the ``filename`` parameter.
:param filename: filename of the source template. This argument is
mutually exclusive versus the ``text`` parameter.
:param buffer_filters: string list of filters to be applied
to the output of ``%def``\ s which are buffered, cached, or otherwise
filtered, after all filters
defined with the ``%def`` itself have been applied. Allows the
creation of default expression filters that let the output
of return-valued ``%def``\ s "opt out" of that filtering via
passing special attributes or objects.
:param cache_args: Dictionary of cache configuration arguments that
will be passed to the :class:`.CacheImpl`. See :ref:`caching_toplevel`.
:param cache_dir:
.. deprecated:: 0.6
Use the ``'dir'`` argument in the ``cache_args`` dictionary.
See :ref:`caching_toplevel`.
:param cache_enabled: Boolean flag which enables caching of this
template. See :ref:`caching_toplevel`.
:param cache_impl: String name of a :class:`.CacheImpl` caching
implementation to use. Defaults to ``'beaker'``.
:param cache_type:
.. deprecated:: 0.6
Use the ``'type'`` argument in the ``cache_args`` dictionary.
See :ref:`caching_toplevel`.
:param cache_url:
.. deprecated:: 0.6
Use the ``'url'`` argument in the ``cache_args`` dictionary.
See :ref:`caching_toplevel`.
:param default_filters: List of string filter names that will
be applied to all expressions. See :ref:`filtering_default_filters`.
:param enable_loop: When ``True``, enable the ``loop`` context variable.
This can be set to ``False`` to support templates that may
be making usage of the name "``loop``". Individual templates can
re-enable the "loop" context by placing the directive
``enable_loop="True"`` inside the ``<%page>`` tag -- see
:ref:`migrating_loop`.
:param encoding_errors: Error parameter passed to ``encode()`` when
string encoding is performed. See :ref:`usage_unicode`.
:param error_handler: Python callable which is called whenever
compile or runtime exceptions occur. The callable is passed
the current context as well as the exception. If the
callable returns ``True``, the exception is considered to
be handled, else it is re-raised after the function
completes. Is used to provide custom error-rendering
functions.
.. seealso::
:paramref:`.Template.include_error_handler` - include-specific
error handler function
:param format_exceptions: if ``True``, exceptions which occur during
the render phase of this template will be caught and
formatted into an HTML error page, which then becomes the
rendered result of the :meth:`.render` call. Otherwise,
runtime exceptions are propagated outwards.
:param imports: String list of Python statements, typically individual
"import" lines, which will be placed into the module level
preamble of all generated Python modules. See the example
in :ref:`filtering_default_filters`.
:param future_imports: String list of names to import from `__future__`.
These will be concatenated into a comma-separated string and inserted
into the beginning of the template, e.g. ``futures_imports=['FOO',
'BAR']`` results in ``from __future__ import FOO, BAR``. If you're
interested in using features like the new division operator, you must
use future_imports to convey that to the renderer, as otherwise the
import will not appear as the first executed statement in the generated
code and will therefore not have the desired effect.
:param include_error_handler: An error handler that runs when this template
is included within another one via the ``<%include>`` tag, and raises an
error. Compare to the :paramref:`.Template.error_handler` option.
.. versionadded:: 1.0.6
.. seealso::
:paramref:`.Template.error_handler` - top-level error handler function
:param input_encoding: Encoding of the template's source code. Can
be used in lieu of the coding comment. See
:ref:`usage_unicode` as well as :ref:`unicode_toplevel` for
details on source encoding.
:param lookup: a :class:`.TemplateLookup` instance that will be used
for all file lookups via the ``<%namespace>``,
``<%include>``, and ``<%inherit>`` tags. See
:ref:`usage_templatelookup`.
:param module_directory: Filesystem location where generated
Python module files will be placed.
:param module_filename: Overrides the filename of the generated
Python module file. For advanced usage only.
:param module_writer: A callable which overrides how the Python
module is written entirely. The callable is passed the
encoded source content of the module and the destination
path to be written to. The default behavior of module writing
uses a tempfile in conjunction with a file move in order
to make the operation atomic. So a user-defined module
writing function that mimics the default behavior would be:
.. sourcecode:: python
import tempfile
import os
import shutil
def module_writer(source, outputpath):
(dest, name) = \\
tempfile.mkstemp(
dir=os.path.dirname(outputpath)
)
os.write(dest, source)
os.close(dest)
shutil.move(name, outputpath)
from mako.template import Template
mytemplate = Template(
filename="index.html",
module_directory="/path/to/modules",
module_writer=module_writer
)
The function is provided for unusual configurations where
certain platform-specific permissions or other special
steps are needed.
:param output_encoding: The encoding to use when :meth:`.render`
is called.
See :ref:`usage_unicode` as well as :ref:`unicode_toplevel`.
:param preprocessor: Python callable which will be passed
the full template source before it is parsed. The return
result of the callable will be used as the template source
code.
:param lexer_cls: A :class:`.Lexer` class used to parse
the template. The :class:`.Lexer` class is used by
default.
.. versionadded:: 0.7.4
:param strict_undefined: Replaces the automatic usage of
``UNDEFINED`` for any undeclared variables not located in
the :class:`.Context` with an immediate raise of
``NameError``. The advantage is immediate reporting of
missing variables which include the name.
.. versionadded:: 0.3.6
:param uri: string URI or other identifier for this template.
If not provided, the ``uri`` is generated from the filesystem
path, or from the in-memory identity of a non-file-based
template. The primary usage of the ``uri`` is to provide a key
within :class:`.TemplateLookup`, as well as to generate the
file path of the generated Python module file, if
``module_directory`` is specified.
NFstrictbeakerT c |r#t j dd| | _ || _ n|rt j dd| | _ t j | \ } } t j | t j j d } | | _ n0dt t | z | _ | j | _ | j } | d r
| dd } t j | } | d r t j d| j z || _ || _ || _ || _ || _ || _ | dg| _ n|| _ || _ || _ || _ || _ ||| _ |8t7 | || \ } } | | _ || _ t= | d | || || n|~||} nb| ^t j t j t j | | d z } nd } | ! | | } nt j" d
| | _# || _$ | j# j% | _& || _' || _( || _) || _* | | _+ | , | | |
|
|| d S ) N\W_/zmemory: z..zNTemplate uri "%s" is invalid - it cannot be relative outside of the root path.strz.pyz"Template requires text or filename)-resub module_iduriospath
splitdrivenormpathreplacesephexid
startswithr TemplateLookupExceptioninput_encodingoutput_encodingencoding_errors enable_loopstrict_undefined
module_writerdefault_filtersbuffer_filtersimportsfuture_imports preprocessor lexer_cls
_compile_text_code_source
ModuleInfoabspathjoin_compile_from_fileRuntimeExceptionmodulefilename render_body callable_format_exceptions
error_handlerinclude_error_handlerlookupmodule_directory_setup_cache_args)!selftextr8 r r; r< r> r$ r% r?
cache_args
cache_impl
cache_enabled
cache_type cache_dir cache_urlmodule_filenamer# r( r) r* r' r+ r, r& r- r. r= driver u_normcoder7 s! _/builddir/build/BUILD/cloudlinux-venv-1.0.12/venv/lib/python3.11/site-packages/mako/template.py__init__zTemplate.__init__ s <
& VE3 4 4DNDHH
& VE3 9 9DN ',,X66KE47##D))11"'+sCCDDHH &RXX 6DN~DH S ! ! ABBZF!!&)) T " " 4$&*h/
- . . & 0 * "$)7D #2D , , ( &DN *4x @ @NT6 DJ DL vtT8T4 E E E E
! *&!-wGLL(()9::FUN ,,T8<
> >rO c || _ || _ |pi | _ |r
|| j d< |r
|| j d< |r || j d< d S d S )Ntypedirurl)rD rE rC )rA rD rE rC rF rG rH s rM r@ zTemplate._setup_cache_args] sk % *$* 1&0DOF # /%.DOE " /%.DOE " " " / /rO c H |St j t j | t j | t
j }t j | r(t j | t
j |k r,t j | }t | |||| j
t j | j
| }|j t j k rFt j | }t | |||| j
t j | j
| }t# ||| |d d d nKt j | }t% | || \ }}d | _ || _ t# |d | ||d d |S N)r verify_directoryr r dirnamestatST_MTIMEexists read_file_compile_module_filer( r load_moduler
_magic_numberr MAGIC_NUMBERr2 r/ r1 r0 )rA r r8 filemtimedatar7 rL s rM r5 zTemplate._compile_from_fileq sx !"'//$"7"7 8 8 8))$-8IGNN4((
74== /);;~h//$$$0B '==F#w';;;~h//$$$0B +DNDAA vtT8T4 F F F F >(++D(tX>>LD& DL DJ vtT8T4 F F F
rO c 4 t | j j S )z t j | | j ||d S )z7Render the output of this template as a unicode object.T)
as_unicodert rv s rM render_unicodezTemplate.render_unicode s* $.$
rO c t |dd | | t j | | j |g|R i | dS )zvRender this :class:`.Template` with the given context.
The data is written to the context's buffer.
_with_templateN)getattr_set_with_templater _render_contextr: )rA contextrw kwargss rM render_contextzTemplate.render_context sX 7 ,d 3 3 ; & &t , , , dngOOOOOOOOOrO c 2 t | j d|z S N render_%s)hasattrr7 rA names rM has_defzTemplate.has_def t{K$$6777rO c N t | t | j d|z S )z9Return a def of this template as a :class:`.DefTemplate`.r ) DefTemplater~ r7 r s rM get_defzTemplate.get_def s% 4kD6H!I!IJJJrO c > d t | j D S )zQreturn a list of defs in the template.
.. versionadded:: 1.0.4
c > g | ]}|d d dk |dd S )N render_r ).0is rM
z&Template.list_defs.. s2 FFF!1RaR5I3E3E!""3E3E3ErO )rX r7 rT s rM list_defszTemplate.list_defs s# GFs4; / /FFFFrO c 2 t | j d|z S r )r~ r7 r s rM _get_def_callablezTemplate._get_def_callable r rO c | j j S r[ )r7 _modified_timerT s rM
last_modifiedzTemplate.last_modified s
{))rO )NNNFNNNr NNr
TNNNNNNNr FNNTNNN)__name__
__module__ __qualname____doc__r r. rN r memoized_propertyrU r@ r5 propertyrj rL r rG rH rF rx r{ r r r r r r r rO rM r r s
B I "9s
s
s
s
j
? ? ? / / /( < E E XE
C C XC
! ! ! & & X& & & X& ' ' X' A A A
P P P8 8 8K K K
G G G8 8 8 * * X* * *rO r c < e Zd ZdZ ddZdS ) ModuleTemplatea- A Template which is constructed given an existing Python module.
e.g.::
t = Template("this is a template")
f = file("mymodule.py", "w")
f.write(t.code)
f.close()
import mymodule
t = ModuleTemplate(mymodule)
print(t.render())
Nr Fr
Tc t j dd|j | _ |j | _ |j | _ || _ || _ |j | _
|| _ || _ t ||| ||||j | j j | _ | | _ |
| _ || _ | | _ | |
|| ||| d S )Nr r )r r
_template_urir r _source_encodingr# r$ r% _enable_loopr& r7 r8 r2 r9 r: r; r< r= r> r@ )rA r7 rI templatetemplate_filename
module_sourcetemplate_sourcer$ r% r; r< r> rC rD rE rF rG rH r= s rM rN zModuleTemplate.__init__ s * sF,@AA' $ 5 . . !. )
0!2 *%:"
rO )NNNNNNr FNNNr
TNNNN)r r r r rN r rO rM r r sg & "'4
4
4
4
4
4
rO r c e Zd ZdZd Zd ZdS )r zNA :class:`.Template` which represents a callable def in a parent
template.c || _ || _ |j | _ |j | _ |j | _ |j | _ |j | _ |j | _ |j | _ |j | _ d S r[ )
parentr: r$ r7 r% r; r< r= r& r> )rA r r: s rM rN zDefTemplate.__init__0 sh " % 5 m % 5 !'!9 # 1%+%A"!- m rO c 6 | j | S r[ )r r r s rM r zDefTemplate.get_def< s {""4(((rO N)r r r r rN r r rO rM r r + s<
$
$
$) ) ) ) )rO r c z e Zd ZdZ ej Zd Zedd Z e
d Z e
d Z dS ) r2 zStores information about a module currently loaded into
memory, provides reverse lookups of template source, module
source code based on a module's identifier.
c || _ || _ || _ || _ || _ || _ | x| j |j < |_ |r | | j |< d S d S r[ ) r7 rI r r r template_uri_modulesr _mmarker)rA r7 rI r r r r r s rM rN zModuleInfo.__init__J sm . !2 * . (=AA
fo&): 2-1DM/ * * * 2 2rO Fc t j d|t j d }t j | }d |d D |d< |rRg x}|d< |d }d}t dt | D ]#}||v r|| }| | $|S )Nz'__M_BEGIN_METADATA(.+?)__M_END_METADATAr c N i | ]"\ }}t | t | #S r )int)r kvs rM
z9ModuleInfo.get_module_source_metadata..d s7 "
"
"
#q!CFFCFF"
"
"
rO line_map
full_line_map)
r searchSgroupjsonloadsitemsrangemaxappend)clsr r
source_map
f_line_mapr curr_templ_linemod_lines rM get_module_source_metadataz%ModuleInfo.get_module_source_metadata^ s Y 6
rt
%(( Z
++
"
"
'1*'='C'C'E'E"
"
"
: 379 9JO4!*-H O !!S]] 3 3
3
3x''&.x&8O!!/2222rO c P | j | j S t j | j S r[ )r r read_python_filerI rT s rM rL zModuleInfo.coder s( )% %()=>> >rO c > | j Ft j | j }| j j r | | j j S |S | j j r>t | j t s$| j | j j S | j S r[ ) r r ra r r7 r decode
isinstancer )rA rg s rM rj zModuleInfo.sourcey s '>$"899D{+
{{4;#?@@@
[
) (* #3
3
( '..t{/KLL L' 'rO N)F)
r r r r weakrefWeakValueDictionaryr rN classmethodr r rL rj r rO rM r2 r2 @ s +w*,,H2 2 2( [& ? ? X?
(
( X
(
(
(rO r2 c | ||| j | j }| }t j || j || j | j | j | j
|j || j | j
| j }||fS )N)r# r- ) r) r* r+ r, source_encodinggenerate_magic_commentr' r& rU )r. r# r- parser compiler r) r* r+ r, encodingr' r& rU )r rB r8 r lexernoderj s rM _compiler s . *
E ;;==D
_ 0 . . 5!2 ( .
F 5=rO c | j }t | ||d \ }}|}t j | }t ||d }t ||j |j ||fS )NFr exec)r r types
ModuleTyper r __dict__) r rB r8
identifierrj r cidr7 rL s rM r/ r/ sv #J $ MFE C
c
"
"F 63 ' 'D v000 F rO c t | ||d \ }}t |t r | |j pd }|r ||| d S t j t j | \ }}t j
|| t j | t j
|| d S )NTr ascii)rX )r r r encoder tempfilemkstempr r r] writecloseshutilmove) r rB r8
outputpathr( rj r destr s rM rb rb s $ MFE &# : u~ 899
&
fj)))))
'BGOOJ,G,GHHH t
v
D*%%%%%rO c 6 t | j d S )Nr )_get_module_info __globals__)r: s rM ri ri s I 1* = > >>rO c & t j | S r[ )r2 r )r8 s rM r r s x ((rO )r r r r r r^ r r r makor r r r r r
mako.lexerr r r r r2 r r/ rb ri r r rO rM r s = =
C* C* C* C* C* C* C* C*LF
F
F
F
F
X F
F
F
R) ) ) ) )( ) ) )*G( G( G( G( G( G( G( G(T 2 & & &*? ? ?) ) ) ) )rO