U
|
Þ=®d¥ï ã @ s d Z ddlZddlZddlZddlZddlmZ ddlmZ ddlm Z ddlm
|
Z
|
ddl m Z ddl mZ d d
|
lmZ d d lmZ d d lmZ d d lmZ d dlmZ d dlmZ d dlmZ d dlmZ d dlmZ d dlmZ d dlm Z d dlm Z d dlm Z d dlm Z d dlm Z d dlm!Z! d dlm"Z" d dlm#Z# d d lm$Z$ d d l%m&Z& d d l%m'Z' d d l%m(Z( d d l%m)Z) d d!l%m*Z* d d"l+m,Z, d d#l+m-Z- d d$l+m.Z. d d%lm/Z/ d d&l0m1Z1 d d'l2m3Z3 d d(l2m4Z4 d d)l2m5Z5 d d*l6m7Z7 d d+l6m8Z8 d d,l6m9Z9 d d-l6m:Z: d d.l6m;Z; d d/l6m<Z< d d0l6m=Z= ej>rtddl?Z@d d1lAmBZB d d2lCmDZD d d3lEmFZF ejGd4d5d6ZHed7d8ejIeH ejJeHd9d:d;ZKeLejMejNejOejPeQf d<f d=d>d?ZRejMejN ejMejNejOejPeQf d<f d@dAdBZSd5ejTejUeQejIdC f ejVeQdCf dDdEdFZWd5d5dGdHdIZXG dJd5 d5ZYG dKd< d<ZZG dLdM dMZ[G dNdO dOZ\G dPdQ dQZ]eZeY_^dS )RzKClasses for managing templates and their runtime and compile time
|
options.
|
é N)ÚChainMap)Ú lru_cache)Úpartial)Úreduce)ÚCodeType)ÚMarkupé )Únodes)Ú CodeGenerator)Úgenerate)ÚBLOCK_END_STRING)ÚBLOCK_START_STRING)ÚCOMMENT_END_STRING)ÚCOMMENT_START_STRING)ÚDEFAULT_FILTERS)ÚDEFAULT_NAMESPACE)ÚDEFAULT_POLICIES)Ú DEFAULT_TESTS)ÚKEEP_TRAILING_NEWLINE)ÚLINE_COMMENT_PREFIX)ÚLINE_STATEMENT_PREFIX)Ú LSTRIP_BLOCKS)ÚNEWLINE_SEQUENCE)Ú TRIM_BLOCKS)ÚVARIABLE_END_STRING)ÚVARIABLE_START_STRING)ÚTemplateNotFound)ÚTemplateRuntimeError)ÚTemplatesNotFound)ÚTemplateSyntaxError)ÚUndefinedError©Ú get_lexer)ÚLexer)Ú TokenStream)Ú EvalContext)ÚParser)ÚContext)Ú new_context)Ú Undefined)Ú_PassArg)Úconcat)Úconsume)Ú import_string)Ú internalcode©ÚLRUCache)Úmissing)Ú BytecodeCache)Ú Extension)Ú
|
BaseLoaderÚ
|
_env_boundÚ Environment)Úboundé
|
)Úmaxsize)ÚclsÚargsÚreturnc G s | | }d|_ |S )a Return a new spontaneous environment. A spontaneous environment
|
is used for templates created directly rather than through an
|
existing environment.
|
|
:param cls: Environment class to create.
|
:param args: Positional arguments passed to environment.
|
T)Úshared)r: r; Úenv© r? úId:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\jinja2/environment.pyÚget_spontaneous_environmentB s rA ÚTemplate©Úsizer< c C s | dkr dS | dk ri S t | S )z*Return the cache class for the given size.r Nr/ )rD r? r? r@ Ú create_cacheP s
|
rE )Úcacher< c C s& | dkr dS t | tkr i S t| jS )z(Create an empty copy of the given cache.N)ÚtypeÚdictr0 Úcapacity)rF r? r? r@ Ú
|
copy_cache] s
|
rJ r3 )Ú environmentÚ
|
extensionsr< c C s@ i }|D ]2}t |tr,t tjd t|¡}|| ||j< q|S )zuLoad the extensions from the list and bind it to the environment.
|
Returns a dict of instantiated extensions.
|
r3 )Ú
|
isinstanceÚstrÚtÚcastÚTyper- Ú
|
identifier)rK rL ÚresultÚ extensionr? r? r@ Úload_extensionsj s
|
rU )rK r< c C sN t | jtstd| j| j kr.| jks8n td| jdksJtd| S )z*Perform a sanity check on the environment.z5'undefined' must be a subclass of 'jinja2.Undefined'.z<block, variable and comment start strings must be different.> ú
|
ú Ú
|
z8'newline_sequence' must be one of '\n', '\r\n', or '\r'.)Ú
|
issubclassÚ undefinedr) ÚAssertionErrorÚblock_start_stringÚvariable_start_stringÚcomment_start_stringÚnewline_sequence)rK r? r? r@ Ú_environment_config_check| s" ÿþþý
|
ü ür` c @ sj e Zd ZU dZdZdZdZejd e d< dZ
|
e Z ej d e d< djZeZej e e d< ej d e d
|
< eeeeeeeeeee e d d e dddd d ddfe e e e e e eje eje e e de ej!ej"e ej d f e ej e ejej#dej$f ej"e ej#eje ge f f ejd e%e ejd e dddZ&ej"e ej d f ddddZ'ej$ddddZ(e)e)e)e)e)e)e)e)e)e)e)e)e)e)e)e)e)e)e)e)e)dfe e e e e e eje eje e e de ej!ej"e ej d f e ej e ejej#dej$f ej"e ej#eje ge f f ejd e%e ejd e d d d d Z*e+e,d d d!Z-ej.d d d"d#Z/ej$ej"e ej$f ej"ej$e f d$d%d&Z0ej$e ej$d'd(d)Z1ej"e e f ej$ejej!ej$ ejej2e ej$f eje eje3 e ej$d*d+d,Z4doe ej$ejej!ej$ ejej2e ej$f eje eje3 ej$d-d.d/Z5dpe ej$ejej!ej$ ejej2e ej$f eje eje3 ej$d-d0d1Z6e7dqe eje eje e8j9d2d3d4Z:e eje eje e8j9d2d5d6Z;dre eje eje ej.ej<e%e e f d2d7d8Z=dse eje eje e d2d9d:Z>dte eje eje eje e?d;d<d=Z@due8j9eje eje e e d>d?d@ZAe e eBdAdBdCZCeDjEdvej"e e8j9f eje eje dDe eBdEdFdGZFeDjEdwej"e e8j9f eje eje dHe e dEdIdGZFe7dxej"e e8j9f eje eje e e ej"e eBf dEdJdGZFdye e dKdLdMdNZGdzej"e eHjIf ejejJe ejej#e ge f eje ejej#e gdf e ddPdQdRZKd{ejejJe ejej#e ge f ejLe dSdTdUZMd|eje dVdWdXdYZNe e e dZd[d\ZOe7e ejejPe ej$f d d]d^d_ZQe7d}ej"e d f eje ejejPe ej$f d d`dadbZRe7d~ejSej"e d f eje ejejPe ej$f d dcdddeZTe7dej"e d ejLej"e d f f eje ejejPe ej$f d dfdgdhZUdej"e e8j9f ejejPe ej$f ejej d d didjdkZVejejPe ej$f ejPe ej$f dldmdnZWdS )r6 a¤ The core component of Jinja is the `Environment`. It contains
|
important shared variables like configuration, filters, tests,
|
globals and others. Instances of this class may be modified if
|
they are not shared and if no template was loaded so far.
|
Modifications on environments after the first template was loaded
|
will lead to surprising effects and undefined behavior.
|
|
Here are the possible initialization parameters:
|
|
`block_start_string`
|
The string marking the beginning of a block. Defaults to ``'{%'``.
|
|
`block_end_string`
|
The string marking the end of a block. Defaults to ``'%}'``.
|
|
`variable_start_string`
|
The string marking the beginning of a print statement.
|
Defaults to ``'{{'``.
|
|
`variable_end_string`
|
The string marking the end of a print statement. Defaults to
|
``'}}'``.
|
|
`comment_start_string`
|
The string marking the beginning of a comment. Defaults to ``'{#'``.
|
|
`comment_end_string`
|
The string marking the end of a comment. Defaults to ``'#}'``.
|
|
`line_statement_prefix`
|
If given and a string, this will be used as prefix for line based
|
statements. See also :ref:`line-statements`.
|
|
`line_comment_prefix`
|
If given and a string, this will be used as prefix for line based
|
comments. See also :ref:`line-statements`.
|
|
.. versionadded:: 2.2
|
|
`trim_blocks`
|
If this is set to ``True`` the first newline after a block is
|
removed (block, not variable tag!). Defaults to `False`.
|
|
`lstrip_blocks`
|
If this is set to ``True`` leading spaces and tabs are stripped
|
from the start of a line to a block. Defaults to `False`.
|
|
`newline_sequence`
|
The sequence that starts a newline. Must be one of ``'\r'``,
|
``'\n'`` or ``'\r\n'``. The default is ``'\n'`` which is a
|
useful default for Linux and OS X systems as well as web
|
applications.
|
|
`keep_trailing_newline`
|
Preserve the trailing newline when rendering templates.
|
The default is ``False``, which causes a single newline,
|
if present, to be stripped from the end of the template.
|
|
.. versionadded:: 2.7
|
|
`extensions`
|
List of Jinja extensions to use. This can either be import paths
|
as strings or extension classes. For more information have a
|
look at :ref:`the extensions documentation <jinja-extensions>`.
|
|
`optimized`
|
should the optimizer be enabled? Default is ``True``.
|
|
`undefined`
|
:class:`Undefined` or a subclass of it that is used to represent
|
undefined values in the template.
|
|
`finalize`
|
A callable that can be used to process the result of a variable
|
expression before it is output. For example one can convert
|
``None`` implicitly into an empty string here.
|
|
`autoescape`
|
If set to ``True`` the XML/HTML autoescaping feature is enabled by
|
default. For more details about autoescaping see
|
:class:`~markupsafe.Markup`. As of Jinja 2.4 this can also
|
be a callable that is passed the template name and has to
|
return ``True`` or ``False`` depending on autoescape should be
|
enabled by default.
|
|
.. versionchanged:: 2.4
|
`autoescape` can now be a function
|
|
`loader`
|
The template loader for this environment.
|
|
`cache_size`
|
The size of the cache. Per default this is ``400`` which means
|
that if more than 400 templates are loaded the loader will clean
|
out the least recently used template. If the cache size is set to
|
``0`` templates are recompiled all the time, if the cache size is
|
``-1`` the cache will not be cleaned.
|
|
.. versionchanged:: 2.8
|
The cache size was increased to 400 from a low 50.
|
|
`auto_reload`
|
Some loaders load templates from locations where the template
|
sources may change (ie: file system or database). If
|
``auto_reload`` is set to ``True`` (default) every time a template is
|
requested the loader checks if the source changed and if yes, it
|
will reload the template. For higher performance it's possible to
|
disable that.
|
|
`bytecode_cache`
|
If set to a bytecode cache object, this object will provide a
|
cache for the internal Jinja bytecode so that templates don't
|
have to be parsed if they were not changed.
|
|
See :ref:`bytecode-cache` for more information.
|
|
`enable_async`
|
If set to true this enables async template execution which
|
allows using async functions and generators.
|
FNÚ linked_tor
|
Úcode_generator_classÚ Ú context_classrB Útemplate_classr? Ti ú te.Literal['\n', '\r\n', '\r']r3 .r4 r2 )r\ Úblock_end_stringr] Úvariable_end_stringr^ Úcomment_end_stringÚline_statement_prefixÚline_comment_prefixÚ trim_blocksÚ lstrip_blocksr_ Úkeep_trailing_newlinerL Ú optimizedrZ ÚfinalizeÚ
|
autoescapeÚloaderÚ
|
cache_sizeÚ auto_reloadÚbytecode_cacheÚ enable_asyncc C s || _ || _|| _|| _|| _|| _|| _|| _| | _|
|
| _ | | _
|
| | _ || _ || _ || _|| _t ¡ | _t ¡ | _t ¡ | _|| _t|| _|| _|| _t ¡ | _ t | | | _ || _ t!| d S ©N)"r\ rg r] rh r^ ri rj rk rl rm r_ rn rZ ro rp rq r ÚcopyÚfiltersr Útestsr Úglobalsrr rE rF ru rt r ZpoliciesrU rL Úis_asyncr` )Úselfr\ rg r] rh r^ ri rj rk rl rm r_ rn rL ro rZ rp rq rr rs rt ru rv r? r? r@ Ú__init__$ s6 %
|
|
|
|
|
zEnvironment.__init__)rT r< c C s | j t| |g¡ dS )z\Adds an extension after the environment was created.
|
|
.. versionadded:: 2.5
|
N)rL ÚupdaterU )r} rT r? r? r@ Ú add_extensionp s zEnvironment.add_extension)Ú
|
attributesr< c K s, | ¡ D ] \}}t| |st| || qdS )zèAdd the items to the instance of the environment if they do not exist
|
yet. This is used by :ref:`extensions <writing-extensions>` to register
|
callbacks and configuration values without breaking inheritance.
|
N)ÚitemsÚhasattrÚsetattr)r} r ÚkeyÚvaluer? r? r@ Úextendw s
|
zEnvironment.extend)r\ rg r] rh r^ ri rj rk rl rm r_ rn rL ro rZ rp rq rr rs rt ru rv r< c C sè t t }|d= |d= |d= |d= t | j¡}|j | j¡ d|_| |_| ¡ D ] \}}|t
|
k rPt ||| qP|t
|
k rt ||_ n t| j |_ i |_| j ¡ D ]\}}| |¡|j|< q| t
|
k rÒ|j t|| ¡ |t
|
k rà||_t|S )a Create a new overlay environment that shares all the data with the
|
current environment except for cache and the overridden attributes.
|
Extensions cannot be removed for an overlayed environment. An overlayed
|
environment automatically gets all the extensions of the environment it
|
is linked to plus optional extra extensions.
|
|
Creating overlays should happen after the initial environment was set
|
up completely. Not all attributes are truly linked, some are just
|
copied over so modifications on the original environment may not shine
|
through.
|
|
.. versionchanged:: 3.1.2
|
Added the ``newline_sequence``,, ``keep_trailing_newline``,
|
and ``enable_async`` parameters to match ``__init__``.
|
r} rs rL rv T)rH ÚlocalsÚobjectÚ__new__Ú __class__Ú__dict__r Ú overlayedra r r1 r rE rF rJ rL ÚbindrU r| r` )r} r\ rg r] rh r^ ri rj rk rl rm r_ rn rL ro rZ rp rq rr rs rt ru rv r; Úrvr
r r? r? r@ Úoverlay s( (
|
zEnvironment.overlay©r< c C s t | S )z The lexer for this environment.r! ©r} r? r? r@ ÚlexerÄ s zEnvironment.lexerc C s t t| j ¡ dd dS )z)Iterates over the extensions by priority.c S s | j S rw )Úpriority©Úxr? r? r@ Ú<lambda>Ë ó z-Environment.iter_extensions.<locals>.<lambda>)r
)ÚiterÚsortedrL Úvaluesr r? r? r@ Úiter_extensionsÉ s zEnvironment.iter_extensions)ÚobjÚargumentr< c C s z
|
|| W S t ttfk
|
r t|trrz t|}W n tk
|
rJ Y n(X zt||W Y S t k
|
rp Y nX | j||d Y S X dS )z:Get an item or attribute of an object but prefer the item.©r ÚnameN)ÚAttributeErrorÚ TypeErrorÚ LookupErrorrM rN Ú ExceptionÚgetattrrZ )r} r r Úattrr? r? r@ ÚgetitemÍ s
|
|
zEnvironment.getitem)r Ú attributer< c
|
C sZ z t ||W S tk
|
r Y nX z
|
|| W S tttfk
|
rT | j||d Y S X dS )zGet an item or attribute of an object but prefer the attribute.
|
Unlike :meth:`getitem` the attribute *must* be a string.
|
r N)r¥ r¡ r¢ r£ rZ )r} r r¨ r? r? r@ r¥ à s
|
zEnvironment.getattr)r r r; ÚkwargsÚcontextÚeval_ctxÚ is_filterr< c
|
C sP |r| j }d} n
|
| j}d} | |¡}
|
|
|
d krd| d|d} t|trz | ¡ W n2 tk
|
r } z| d| d} W 5 d } ~ X Y nX t| |f|d k r |nd}|d k r²|ni }t |
|
¡} | tj
|
krð|d krâtd | d
|
| d |¡ nV| tj kr.|d kr |d k r|j }nt| }| d |¡ n| tjkrF| d | ¡ |
|
||S ) NÚfilterÚtestzNo z named Ú.z (z-; did you forget to quote the callable name?)r? z Attempted to invoke a context z without context.r )ry rz ÚgetrM r) Ú_fail_with_undefined_errorr¤ r r* Zfrom_objrª ÚinsertZ eval_contextr« r% rK )r} r r r; r© rª r« r¬ Zenv_mapZ type_nameÚfuncÚmsgÚeZpass_argr? r? r@ Ú_filter_test_commoní s@
|
|
|
"
|
|
|
ÿ
|
|
z Environment._filter_test_common)r r r; r© rª r« r< c C s | ||||||d¡S )a/ Invoke a filter on a value the same way the compiler does.
|
|
This might return a coroutine if the filter is running from an
|
environment in async mode and the filter supports async
|
execution. It's your responsibility to await this if needed.
|
|
.. versionadded:: 2.7
|
T©r¶ ©r} r r r; r© rª r« r? r? r@ Ú call_filter# s ÿzEnvironment.call_filterc C s | ||||||d¡S )aÇ Invoke a test on a value the same way the compiler does.
|
|
This might return a coroutine if the test is running from an
|
environment in async mode and the test supports async execution.
|
It's your responsibility to await this if needed.
|
|
.. versionchanged:: 3.0
|
Tests support ``@pass_context``, etc. decorators. Added
|
the ``context`` and ``eval_ctx`` parameters.
|
|
.. versionadded:: 2.7
|
Fr· r¸ r? r? r@ Ú call_test8 s ÿzEnvironment.call_test)Úsourcer Úfilenamer< c C s6 z| |||¡W S tk
|
r0 | j|d Y nX dS )a Parse the sourcecode and return the abstract syntax tree. This
|
tree of nodes is used by the compiler to convert the template into
|
executable source- or bytecode. This is useful for debugging or to
|
extract information from templates.
|
|
If you are :ref:`developing Jinja extensions <writing-extensions>`
|
this gives you a good overview of the node tree generated.
|
©r» N)Ú_parser Úhandle_exception©r} r» r r¼ r? r? r@ ÚparseQ s zEnvironment.parsec C s t | ||| ¡ S )z8Internal parsing function used by `parse` and `compile`.)r& rÁ rÀ r? r? r@ r¾ e s zEnvironment._parsec C s@ t |}z| j |||¡W S tk
|
r: | j|d Y nX dS )aº Lex the given sourcecode and return a generator that yields
|
tokens as tuples in the form ``(lineno, token_type, value)``.
|
This can be useful for :ref:`extension development <writing-extensions>`
|
and debugging templates.
|
|
This does not perform preprocessing. If you want the preprocessing
|
of the extensions to be applied you have to filter source through
|
the :meth:`preprocess` method.
|
r½ N)rN r Z tokeniterr r¿ rÀ r? r? r@ Úlexk s
|
zEnvironment.lexc s t fdd| ¡ t|S )zäPreprocesses the source with all extensions. This is automatically
|
called for all parsing and compiling methods but *not* for :meth:`lex`
|
because there you usually only want the actual source tokenized.
|
c s | | ¡S rw )Ú
|
preprocess)Úsrµ ©r¼ r r? r@ r r z(Environment.preprocess.<locals>.<lambda>)r r rN rÀ r? rÅ r@ rà s
|
|
ýzEnvironment.preprocess)r» r r¼ Ústater< c C sR | |||¡}| j ||||¡}| ¡ D ]$}| |¡}t|ts(t|||}q(|S )zCalled by the parser to do the preprocessing and filtering
|
for all the extensions. Returns a :class:`~jinja2.lexer.TokenStream`.
|
)rà r Útokenizer Z filter_streamrM r$ )r} r» r r¼ rÆ ÚstreamÚextr? r? r@ Ú _tokenize s
|
|
|
zEnvironment._tokenize)r» r r¼ Ú
|
defer_initr< c C s t || |||| jdS )z|Internal hook that can be overridden to hook a different generate
|
method in.
|
|
.. versionadded:: 2.5
|
)rË ro )r ro )r} r» r r¼ rË r? r? r@ Ú _generate¥ s úzEnvironment._generate)r» r¼ r< c C s t ||dS )z{Internal hook that can be overridden to hook a different compile
|
method in.
|
|
.. versionadded:: 2.5
|
Úexec)Úcompile)r} r» r¼ r? r? r@ Ú_compileº s zEnvironment._compilezte.Literal[False])r» r r¼ ÚrawrË r< c C s d S rw r? ©r} r» r r¼ rÐ rË r? r? r@ rÎ Â s zEnvironment.compilezte.Literal[True]c C s d S rw r? rÑ r? r? r@ rÎ Í s c C s| d}zRt |tr"|}| |||¡}| j||||d}|r>|W S |dkrJd}| ||¡W S tk
|
rv | j|d Y nX dS )a Compile a node or template source code. The `name` parameter is
|
the load name of the template after it was joined using
|
:meth:`join_path` if necessary, not the filename on the file system.
|
the `filename` parameter is the estimated filename of the template on
|
the file system. If the template came from a database or memory this
|
can be omitted.
|
|
The return value of this method is a python code object. If the `raw`
|
parameter is `True` the return value will be a string with python
|
code equivalent to the bytecode returned otherwise. This method is
|
mainly used internally.
|
|
`defer_init` is use internally to aid the module code generator. This
|
causes the generated code to be able to import without the global
|
environment variable to be set.
|
|
.. versionadded:: 2.4
|
`defer_init` parameter added.
|
N)rË z
|
<template>r½ )rM rN r¾ rÌ rÏ r r¿ )r} r» r r¼ rÐ rË Z source_hintr? r? r@ rÎ Ø s
|
ÚTemplateExpression)r» Úundefined_to_noner< c C s t | |dd}z2| ¡ }|jjs4td|jjjdd| | ¡ W n tk
|
r` | j|d Y nX t j
|
t dd¡|dd g}| t j |dd ¡}t||S )
|
a A handy helper method that returns a callable that accepts keyword
|
arguments that appear as variables in the expression. If called it
|
returns the result of the expression.
|
|
This is useful if applications want to use the same rules as Jinja
|
in template "configuration files" or similar situations.
|
|
Example usage:
|
|
>>> env = Environment()
|
>>> expr = env.compile_expression('foo == 42')
|
>>> expr(foo=23)
|
False
|
>>> expr(foo=42)
|
True
|
|
Per default the return value is converted to `None` if the
|
expression returns an undefined value. This can be changed
|
by setting `undefined_to_none` to `False`.
|
|
>>> env.compile_expression('var')() is None
|
True
|
>>> env.compile_expression('var', undefined_to_none=False)()
|
Undefined
|
|
.. versionadded:: 2.1
|
Úvariable)rÆ zchunk after expressionNr½ rS Ústorer )Úlineno)r& Zparse_expressionrÈ Zeosr ÚcurrentrÖ Zset_environmentr¿ r ZAssignÚNameÚ from_stringrB rÒ )r} r» rÓ ÚparserÚexprÚbodyÚtemplater? r? r@ Úcompile_expression s ÿz Environment.compile_expressionÚdeflated)ÚtargetrL Ú filter_funcÚzipÚ log_functionÚ ignore_errorsr< c s ddl m} |dkr$tdddd}|dk s0t| jdk sBtdttdd fd d
|
}dk r¦d d lm} m m}
|
m } | d t
|
|
|
| d |d n$t j ¡s¼t ¡ |d z²| ||¡D ] } | j | | ¡\} }}z| | | |dd¡}W nH tk
|
rN } z(|s" |d| d| W Y ¢qØW 5 d}~X Y nX | | ¡}||| |d| d| qØW 5 r ¡ X |d dS )a3 Finds all the templates the loader can find, compiles them
|
and stores them in `target`. If `zip` is `None`, instead of in a
|
zipfile, the templates will be stored in a directory.
|
By default a deflate zip algorithm is used. To switch to
|
the stored algorithm, `zip` can be set to ``'stored'``.
|
|
`extensions` and `filter_func` are passed to :meth:`list_templates`.
|
Each template returned will be compiled to the target folder or
|
zipfile.
|
|
By default template compilation errors are ignored. In case a
|
log function is provided, errors are logged. If you want template
|
syntax errors to abort the compilation you can set `ignore_errors`
|
to `False` and you will get an exception on syntax errors.
|
|
.. versionadded:: 2.4
|
r )Ú ModuleLoaderN©r r< c S s d S rw r? r r? r? r@ rã M s z3Environment.compile_templates.<locals>.log_functionúNo loader configured.)r¼ Údatar< c sT r | }d|_ ||¡ n0ttj | ¡d}| | d¡¡ W 5 Q R X d S )Ni íÚwbÚutf8)Ú external_attrÚwritestrÚopenÚosÚpathÚjoinÚwriteÚencode)r¼ rè ÚinfoÚf©ÚZipInforà râ Úzip_filer? r@ Ú
|
write_fileS s z1Environment.compile_templates.<locals>.write_filer )ÚZipFilerö Ú ZIP_DEFLATEDÚ
|
ZIP_STOREDÚw)rß ZstoredzCompiling into Zip archive zCompiling into folder TzCould not compile "z": z
|
Compiled "z" as z Finished compiling templates)Úloadersrå rN r[ rr Úzipfilerù rö rú rû rH rî rï ÚisdirÚmakedirsÚcloseÚlist_templatesÚ
|
get_sourcerÎ r Zget_module_filename)r} rà rL rá râ rã rä rå rø rù rú rû r r» r¼ Ú_Úcoderµ r? rõ r@ Úcompile_templates/ sB ÿ
|
|
|
|
z Environment.compile_templates)rL rá r< c sf | j dk std| j ¡ } dk rHdk r4tdttd fdd dk rbfdd|D }|S ) aª Returns a list of templates for this environment. This requires
|
that the loader supports the loader's
|
:meth:`~BaseLoader.list_templates` method.
|
|
If there are other files in the template folder besides the
|
actual templates, the returned list can be filtered. There are two
|
ways: either `extensions` is set to a list of file extensions for
|
templates, or a `filter_func` can be provided which is a callable that
|
is passed a template name and should return `True` if it should end up
|
in the result list.
|
|
If the loader does not support that, a :exc:`TypeError` is raised.
|
|
.. versionadded:: 2.4
|
Nrç z<either extensions or filter_func can be passed, but not bothræ c s d| ko| dd¡d kS )Nr¯ r )Úrsplitr )rL r? r@ rá s z/Environment.list_templates.<locals>.filter_funcc s g | ]} |r|qS r? r? )Ú.0r )rá r? r@ Ú
|
<listcomp> s z.Environment.list_templates.<locals>.<listcomp>)rr r[ r r¢ rN Úbool)r} rL rá Únamesr? )rL rá r@ r } s
|
ÿzEnvironment.list_templatesz te.NoReturn)r» r< c C s ddl m} ||ddS )zException handling helper. This is used internally to either raise
|
rewritten exceptions or return a rendered traceback for the template.
|
r )Úrewrite_traceback_stackr½ N)Údebugr )r} r» r r? r? r@ r¿ ¢ s z Environment.handle_exception)rÝ Úparentr< c C s |S )a Join a template with the parent. By default all the lookups are
|
relative to the loader root so this method returns the `template`
|
parameter unchanged, but if the paths should be relative to the
|
parent template, this function can be used to calculate the real
|
template name.
|
|
Subclasses may override this method and implement template path
|
joining here.
|
r? )r} rÝ r r? r? r@ Ú join_pathª s
|
zEnvironment.join_path)r r{ r< c C s | j d krtdt | j ¡|f}| jd k r`| j |¡}|d k r`| jrL|jr`|r\|j |¡ |S | j
|
| || |¡¡}| jd k r|| j|< |S )Nz(no loader for this environment specified) rr r¢ ÚweakrefÚrefrF r° rt Ú is_up_to_dater{ r ÚloadÚ make_globals)r} r r{ Ú cache_keyrÝ r? r? r@ Ú_load_template¶ s"
|
|
ÿÿ
|
|
zEnvironment._load_template)r r r{ r< c C s. t |tr|S |dk r"| ||¡}| ||¡S )aH Load a template by name with :attr:`loader` and return a
|
:class:`Template`. If the template does not exist a
|
:exc:`TemplateNotFound` exception is raised.
|
|
:param name: Name of the template to load. When loading
|
templates from the filesystem, "/" is used as the path
|
separator, even on Windows.
|
:param parent: The name of the parent template importing this
|
template. :meth:`join_path` can be used to implement name
|
transformations with this.
|
:param globals: Extend the environment :attr:`globals` with
|
these extra variables available for all renders of this
|
template. If the template has already been loaded and
|
cached, its globals are updated with any new items.
|
|
.. versionchanged:: 3.0
|
If a template is loaded from cache, ``globals`` will update
|
the template's globals instead of ignoring the new values.
|
|
.. versionchanged:: 2.4
|
If ``name`` is a :class:`Template` object it is returned
|
unchanged.
|
N)rM rB r r )r} r r r{ r? r? r@ Ú get_templateÏ s
|
|
zEnvironment.get_template)r r r{ r< c
|
C s t |tr| ¡ |s tdd|D ]V}t |tr:| S |dk rN| ||¡}z| ||¡W S ttfk
|
rx Y q$X q$t|dS )aø Like :meth:`get_template`, but tries loading multiple names.
|
If none of the names can be loaded a :exc:`TemplatesNotFound`
|
exception is raised.
|
|
:param names: List of template names to try loading in order.
|
:param parent: The name of the parent template importing this
|
template. :meth:`join_path` can be used to implement name
|
transformations with this.
|
:param globals: Extend the environment :attr:`globals` with
|
these extra variables available for all renders of this
|
template. If the template has already been loaded and
|
cached, its globals are updated with any new items.
|
|
.. versionchanged:: 3.0
|
If a template is loaded from cache, ``globals`` will update
|
the template's globals instead of ignoring the new values.
|
|
.. versionchanged:: 2.11
|
If ``names`` is :class:`Undefined`, an :exc:`UndefinedError`
|
is raised instead. If no templates were found and ``names``
|
contains :class:`Undefined`, the message is more helpful.
|
|
.. versionchanged:: 2.4
|
If ``names`` contains a :class:`Template` object it is
|
returned unchanged.
|
|
.. versionadded:: 2.3
|
z0Tried to select from an empty list of templates.)ÚmessageN) rM r) r± r rB r r r r )r} r r r{ r r? r? r@ Úselect_templateô s #
|
ÿ
|
zEnvironment.select_template)Útemplate_name_or_listr r{ r< c C s8 t |ttfr | |||¡S t |tr*|S | |||¡S )z¤Use :meth:`select_template` if an iterable of template names
|
is given, or :meth:`get_template` if one name is given.
|
|
.. versionadded:: 2.3
|
)rM rN r) r rB r )r} r r r{ r? r? r@ Úget_or_select_template* s
|
|
z"Environment.get_or_select_template)r» r{ re r< c C s* | |¡}|p| j}| | | |¡|d¡S )aý Load a template from a source string without using
|
:attr:`loader`.
|
|
:param source: Jinja source to compile into a template.
|
:param globals: Extend the environment :attr:`globals` with
|
these extra variables available for all renders of this
|
template. If the template has already been loaded and
|
cached, its globals are updated with any new items.
|
:param template_class: Return an instance of this
|
:class:`Template` class.
|
N)r re Ú from_coderÎ )r} r» r{ re Zgsr: r? r? r@ rÙ > s
|
|
zEnvironment.from_string)Údr< c C s |dkr i }t || jS )aS Make the globals map for a template. Any given template
|
globals overlay the environment :attr:`globals`.
|
|
Returns a :class:`collections.ChainMap`. This allows any changes
|
to a template's globals to only affect that template, while
|
changes to the environment's globals are still reflected.
|
However, avoid modifying any globals after a template is loaded.
|
|
:param d: Dict of template-specific globals.
|
|
.. versionchanged:: 3.0
|
Use :class:`collections.ChainMap` to always prevent mutating
|
environment globals.
|
N)r r{ )r} r r? r? r@ r S s zEnvironment.make_globals)NNNN)NNNN)NN)NN)NN)NN)F)NNFF)NN.F)NNFF)T)NNrß NT)NN)N)NN)NN)NN)NN)XÚ__name__Ú
|
__module__Ú __qualname__Ú__doc__Z sandboxedr ra rO ÚOptionalÚ__annotations__r= r
|
rb rQ rð r+ r' rd r r r r r r r r r r r r r) rN r
|
ÚSequenceÚUnionÚCallableÚAnyÚintr~ r r r1 r Úpropertyr# r ÚIteratorr r§ r¥ ÚMappingr% r¶ r¹ rº r. r rB rÁ r¾ ÚTupler rà r$ rÊ rÌ r rÏ ÚtypingÚoverloadrÎ rÞ rî ÚPathLikeÚ
|
Collectionr ÚListr r¿ r ÚMutableMappingr r ÚIterabler r rÙ r r? r? r? r@ r6 sh
|
}é é L é è D þ ÷ : ùø ùø üû þ üû üû ûú ûú úù
|
úù
|
ú ù* ÿ þ 0 ùø P ýü % þ ü û$ üû5 úÿù üû þc @ sÞ e Zd ZU dZeZeje ed< eed< ej e
|
ej f ed< ej e
|
ed< ej e
|
ed< ej e
|
ejegeje
|
f f ed< ejegeje
|
f ed< ej d ed
|
< e
|
ed < ej ejg ef ed < eeeeeeeeeee e d de dddfej e
|
e j!f e
|
e
|
e
|
e
|
e
|
e
|
ej e
|
ej e
|
eedeej"ej e
|
ejd f eeje ej ejdej f ej eejej e
|
gef f eej dddZ#e$dDee%ej e
|
ej f ej ejg ef d dddZ&e$eej e
|
ej f ej e
|
ej f d ddd Z'e$eej e
|
ej f ej e
|
ej f d d d d Z(ej ej e
|
d d!d"Z)ej ej e
|
d d#d$Z*ej ej d%d d&d'Z+ej ej eje
|
d d(d)Z,ej ej ej-e
|
d d*d+Z.dEej ej e
|
ej f eej ej/e
|
ej f ed,d-d.Z0dFej ej e
|
ej f eej ej/e
|
ej f d d,d/d0Z1dGej ej e
|
ej f eej ej/e
|
ej f d d,d1d2Z2e3dHej e d d3d4d5Z4dIej e d d3d6d7Z5e6d d8d9d:Z7e8e8d;d<d=Z9e6ed8d>d?Z:e6ej;ej<e8e8f d8d@dAZ=e
|
d8dBdCZ>dS )JrB ao A compiled template that can be rendered.
|
|
Use the methods on :class:`Environment` to create or load templates.
|
The environment is used to configure how templates are compiled and
|
behave.
|
|
It is also possible to create a template object directly. This is
|
not usually recommended. The constructor takes most of the same
|
arguments as :class:`Environment`. All templates created with the
|
same environment arguments share the same ephemeral ``Environment``
|
instance behind the scenes.
|
|
A template object should be considered immutable. Modifications on
|
the object are not supported.
|
Úenvironment_classrK r{ r r¼ ÚblocksÚroot_render_funcÚTemplateModuleÚ_moduleÚ _debug_infoÚ _uptodater? TNFrf r3 .)r» r\ rg r] rh r^ ri rj rk rl rm r_ rn rL ro rZ rp rq rv r< c C sH t | j|||||||| |
|
| | | t|||||d ddd |}|j|| dS )Nr F)re )rA r4 Ú frozensetrÙ )r: r» r\ rg r] rh r^ ri rj rk rl rm r_ rn rL ro rZ rp rq rv r> r? r? r@ r s4 ézTemplate.__new__)rK r r{ Úuptodater< c C s. ||j d}t|| | |||¡}||_|S )zCreates a template object from compiled code and the globals. This
|
is used by the loaders and environment to create a template object.
|
)rK Ú__file__)Ú co_filenamerÍ Ú_from_namespacer: )r: rK r r{ r< Ú namespacer r? r? r@ r º s
|
|
zTemplate.from_code)rK Ú module_dictr{ r< c C s | |||¡S )zCreates a template object from a module. This is used by the
|
module loader to create a template object.
|
|
.. versionadded:: 2.4
|
)r? )r: rK rA r{ r? r? r@ Úfrom_module_dictË s zTemplate.from_module_dict)rK r@ r{ r< c C sh t | ¡}||_||_|d |_|d |_|d |_|d |_d |_|d |_ d |_
|
||d< ||d< |S )Nr r= r5 ÚrootÚ
|
debug_inforK Z__jinja_template__) r r rK r{ r r¼ r5 r6 r8 r9 r: )r: rK r@ r{ rO r? r? r@ r? Ù s
|
|
|
|
|
|
zTemplate._from_namespace©r; r© r< c O s° | j jrhddl}d}z | ¡ }W n tk
|
r@ | ¡ }d}Y nX z| | j||¡W ¢S |rf| ¡ X | t
|
||¡}z| j | |¡¡W S t k
|
rª | j ¡ Y nX dS )a This method accepts the same arguments as the `dict` constructor:
|
A dict, a dict subclass or some keyword arguments. If no arguments
|
are given the context will be empty. These two calls do the same::
|
|
template.render(knights='that say nih')
|
template.render({'knights': 'that say nih'})
|
|
This will return the rendered template as a string.
|
r NFT)rK r| ÚasyncioZget_running_loopÚ RuntimeErrorZnew_event_loopr Zrun_until_completeÚ render_asyncr( rH r+ r6 r¤ r¿ )r} r; r© rF r ZloopÚctxr? r? r@ Úrenderõ s"
|
|
|
zTemplate.renderc Ï sh | j jstd| t||¡}z$| j dd | |¡2 I dH ¡W S tk
|
rb | j ¡ Y S X dS )a. This works similar to :meth:`render` but returns a coroutine
|
that when awaited returns the entire rendered template string. This
|
requires the async feature to be enabled.
|
|
Example usage::
|
|
await template.render_async(knights='that say nih; asynchronously')
|
ú8The environment was not created with async mode enabled.c Ó s g | z3 d H W }|q6 S rw r? )r Únr? r? r@ r ) s z)Template.render_async.<locals>.<listcomp>N) rK r| rG r( rH r+ r6 r¤ r¿ )r} r; r© rI r? r? r@ rH s ÿÿzTemplate.render_asyncÚTemplateStreamc O s t | j||S )z[Works exactly like :meth:`generate` but returns a
|
:class:`TemplateStream`.
|
)rM r )r} r; r© r? r? r@ rÈ . s zTemplate.streamc / s j jrBddl}tjt d fdd }| | ¡E dH dS t ¡}z |¡E dH W n t
|
k
|
r j ¡ V Y nX dS )ab For very large templates it can be useful to not render the whole
|
template at once but evaluate each statement after another and yield
|
piece for piece. This method basically does exactly that and returns
|
a generator that yields one item after another as strings.
|
|
It accepts the same arguments as :meth:`render`.
|
r Nr c s dd j 2 I d H S )Nc Ó s g | z3 d H W }|q6 S rw r? ©r r r? r? r@ r @ s z6Template.generate.<locals>.to_list.<locals>.<listcomp>)Úgenerate_asyncr? ©r; r© r} r? r@ Úto_list? s z"Template.generate.<locals>.to_list) rK r| rF rO r1 rN Úrunr( rH r6 r¤ r¿ )r} r; r© rF rQ rI r? rP r@ r 4 s zTemplate.generatec O sj | j jstd| t||¡}z$| |¡2 z3 dH W }|V q,6 W n tk
|
rd | j ¡ V Y nX dS )zsAn async version of :meth:`generate`. Works very similarly but
|
returns an async iterator instead.
|
rK N)rK r| rG r( rH r6 r¤ r¿ )r} r; r© rI Úeventr? r? r@ rO L s ÿzTemplate.generate_async)Úvarsr= r r< c C s t | j| j| j||| j|S )a^ Create a new :class:`Context` for this template. The vars
|
provided will be passed to the template. Per default the globals
|
are added to the context. If shared is set to `True` the data
|
is passed as is to the context without adding the globals.
|
|
`locals` can be a dict of local variables for internal usage.
|
)r( rK r r5 r{ )r} rT r= r r? r? r@ r( _ s ÿzTemplate.new_contextc C s | |||¡}t| |S )aJ This method works like the :attr:`module` attribute when called
|
without arguments but it will evaluate the template on every call
|
rather than caching it. It's also possible to provide
|
a dict which is then used as context. The arguments are the same
|
as for the :meth:`new_context` method.
|
)r( r7 ©r} rT r= r rI r? r? r@ Ú make_modulep s zTemplate.make_modulec à s0 | |||¡}t| |dd | |¡2 I dH S )zûAs template module creation can invoke template code for
|
asynchronous executions this method must be used instead of the
|
normal :meth:`make_module` one. Likewise the module attribute
|
becomes unavailable in async mode.
|
c Ó s g | z3 d H W }|q6 S rw r? rN r? r? r@ r s z.Template.make_module_async.<locals>.<listcomp>N)r( r7 r6 rU r? r? r@ Úmake_module_async s ÿzTemplate.make_module_async)rI r< c s^ | j jrtd dk rD j| j ¡ }|rD| fdd|D ¡S | jdkrX| ¡ | _| jS )aO If a context is passed in, this means that the template was
|
imported. Imported templates have access to the current
|
template's globals by default, but they can only be accessed via
|
the context during runtime.
|
|
If there are new globals, we need to create a new module because
|
the cached module is already rendered and will not have access
|
to globals from the current context. This new module is not
|
cached because the template can be imported elsewhere, and it
|
should have access to only the current template's globals.
|
z&Module is not available in async mode.Nc s i | ]}| j | qS r? ©r ©r Úk©rI r? r@ Ú
|
<dictcomp>£ s z0Template._get_default_module.<locals>.<dictcomp>)rK r| rG Ú globals_keysr{ ÚkeysrV r8 ©r} rI r^ r? r[ r@ Ú_get_default_module s
|
|
z Template._get_default_modulec sZ d k r: j | j ¡ }|r:| fdd|D ¡I d H S | jd krT| ¡ I d H | _| jS )Nc s i | ]}| j | qS r? rX rY r[ r? r@ r\ ± s z6Template._get_default_module_async.<locals>.<dictcomp>)r] r{ r^ rW r8 r_ r? r[ r@ Ú_get_default_module_asyncª s
|
z"Template._get_default_module_asyncr c C s | ¡ S )a The template as module. This is used for imports in the
|
template runtime but is also useful if one wants to access
|
exported template variables from the Python layer:
|
|
>>> t = Template('{% macro foo() %}42{% endmacro %}23')
|
>>> str(t.module)
|
'23'
|
>>> t.module.foo() == u'42'
|
True
|
|
This attribute is not available if async mode is enabled.
|
)r` r r? r? r@ Úmodule¸ s zTemplate.module)rÖ r< c C s( t | jD ]\}}||kr
|
| S q
|
dS )zrReturn the source line number of a line number in the
|
generated bytecode as they are not in sync.
|
r )ÚreversedrD )r} rÖ Z template_lineZ code_liner? r? r@ Úget_corresponding_linenoÈ s
|
z!Template.get_corresponding_linenoc C s | j dkrdS | ¡ S )z?If this variable is `False` there is a newer version available.NT)r: r r? r? r@ r Ñ s
|
zTemplate.is_up_to_datec C s | j r dd | j d¡D S g S )zThe debug info mapping.c S s g | ]}t tt| d ¡qS )ú=)ÚtupleÚmapr( ÚsplitrN r? r? r@ r Ü s ÿz'Template.debug_info.<locals>.<listcomp>ú&)r9 rh r r? r? r@ rD Ø s
|
|
þzTemplate.debug_infoc C s> | j d kr dt| d}n
|
t| j }dt| j d| dS ©Nzmemory:r ú<ú ú>)r ÚidÚreprrG r ©r} r r? r? r@ Ú__repr__ã s
|
|
zTemplate.__repr__)N)NFN)NFN)NFN)N)N)?r r r r! r6 r4 rO rQ r# r2 rN r' r" ÚDictr& r' r* r
|
r r r r r r r r r r r r r) r% r rB r$ r Ú classmethodr r rB r? rJ rH rÈ r Ú AsyncIteratorrO r+ r( rV rW r. r` ra r) rb r( rd r r1 r, rD rq r? r? r? r@ rB j sô
|
$ì ë 1 ûúû û" þ üû üû üû ÿþ
|
c @ s\ e Zd ZdZd eeejeje ddddZ
|
e dddZ e dd d
|
Z e dd d ZdS )r7 zÁRepresents an imported template. All the exported names of the
|
template are available as attributes on this object. Additionally
|
converting it into a string renders the contents.
|
N)rÝ rª Ú body_streamr< c C sH |d kr&|j jrtdt| |¡}|| _| j | ¡ ¡ |j | _
|
d S )NztAsync mode requires a body stream to be passed to a template module. Use the async methods of the API you are using.) rK r| rG Úlistr6 Ú _body_streamr r Z get_exportedr r )r} rÝ rª ru r? r? r@ r~ ñ s ÿzTemplateModule.__init__r c C s t t| jS rw )r r+ rw r r? r? r@ Ú__html__ s zTemplateModule.__html__c C s
|
t | jS rw )r+ rw r r? r? r@ Ú__str__ s zTemplateModule.__str__c C s> | j d kr dt| d}n
|
t| j }dt| j d| dS rj )r rn ro rG rp r? r? r@ rq s
|
|
zTemplateModule.__repr__)N)r r r r! rB r' rO r" r3 rN r~ r rx ry rq r? r? r? r@ r7 ë s üû r7 c @ s@ e Zd ZdZeeddddZejejej ej dddZ
|
dS ) rÒ zÂThe :meth:`jinja2.Environment.compile_expression` method returns an
|
instance of this object. It encapsulates the expression-like access
|
to the template with an expression it wraps.
|
N)rÝ rÓ r< c C s || _ || _d S rw )Ú _templateÚ_undefined_to_none)r} rÝ rÓ r? r? r@ r~ s zTemplateExpression.__init__rE c O sD | j t||¡}t| j |¡ |jd }| jr@t|tr@d }|S )NrS ) rz r( rH r, r6 rT r{ rM r) )r} r; r© rª r r? r? r@ Ú__call__ s
|
zTemplateExpression.__call__) r r r r! rB r
|
r~ rO r' r" r| r? r? r? r@ rÒ s rÒ c @ s¦ e Zd ZdZeje ddddZdejeej f ej
|
e ej
|
e dddd Z dd
|
d d Z e eje d ddZde dd ddZd d
|
ddZed
|
ddZdS )rM aû A template stream works pretty much like an ordinary python generator
|
but it can buffer multiple items to reduce the number of total iterations.
|
Per default the output is unbuffered which means that for every unbuffered
|
instruction in the template one string is yielded.
|
|
If buffering is enabled with a buffer size of 5, five items are combined
|
into a new string. This is mainly useful if you are streaming
|
big templates to a client via WSGI which flushes after each iteration.
|
N)Úgenr< c C s || _ | ¡ d S rw )Ú_genÚdisable_buffering)r} r} r? r? r@ r~ 1 s zTemplateStream.__init__Ústrict)ÚfpÚencodingÚerrorsr< c s d}t |tr( dkrd t|d}d}zP dk rH fdd| D }n| }t|drb| |¡ n|D ]}| |¡ qfW 5 |r| ¡ X dS ) a Dump the complete stream into a file or file-like object.
|
Per default strings are written, if you want to encode
|
before writing specify an `encoding`.
|
|
Example usage::
|
|
Template('Hello {{ name }}!').stream(name='foo').dump('hello.html')
|
FNzutf-8ré Tc 3 s | ]}| ¡V qd S rw )rò rN ©r r r? r@ Ú <genexpr>M s z&TemplateStream.dump.<locals>.<genexpr>Ú
|
writelines)rM rN rí r r r rñ )r} r r r r ÚiterableÚitemr? r r@ Údump5 s
|
|
|
zTemplateStream.dumpr c C s t t| j| _d| _dS )z Disable the output buffering.FN)r Únextr~ Ú_nextÚbufferedr r? r? r@ r Z s z TemplateStream.disable_bufferingrC c c sx g }d}|j }z,||k r8t| j}|| |r|d7 }qW n tk
|
rX |sTY d S Y nX t|V |d d
= d}qd S )Nr r )Úappendr r~ Ú StopIterationr+ )r} rD ÚbufZc_sizeÚpushÚcr? r? r@ Ú_buffered_generator_ s
|
|
|
z"TemplateStream._buffered_generatoré c C s, |dkrt dd| _tt| |¡| _dS )z<Enable buffering. Buffer `size` items before yielding them.r zbuffer size too smallTN)Ú
|
ValueErrorr r r r r )r} rD r? r? r@ Úenable_bufferingr s z TemplateStream.enable_bufferingc C s | S rw r? r r? r? r@ Ú__iter__z s zTemplateStream.__iter__c C s | ¡ S rw )r r r? r? r@ Ú__next__} s zTemplateStream.__next__)Nr )r )r r r r! rO r* rN r~ r% ÚIOr" r r r( r r r r r? r? r? r@ rM & s
|
üû %rM )_r! rî r- rO r Ú collectionsr Ú functoolsr r r Útypesr Z
|
markupsafer rc r Úcompilerr
|
r Údefaultsr r r r r r r r r r r r r r r r Ú
|
exceptionsr r r r r r r" r# r$ r% rÚ r& Zruntimer' r( r) Úutilsr* r+ r, r- r. r0 r1 Ú TYPE_CHECKINGZtyping_extensionsÚteZbccacher2 rÉ r3 rý r4 ÚTypeVarr5 rQ r' rA r( r" r2 r, r rN rE rJ r$ r% rr rU r` r6 rB r7 rÒ rM re r? r? r? r@ Ú<module> s¨ þ
|
þ ý c (]
|
