U
|
Þ=®dÑ ã 7 @ sÌ d Z ddlZddlZddlZddlZddlZddlmZ ddlm Z ddlm
|
Z
|
ddl m 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 dlm Z d dlm Z d dlm Z d dlm Z ej rbddl!Z"d dl#m$Z$ d dl%m&Z& d dlm'Z' d dl(m)Z) G dd d e"j*Z+ej,d ej-d ej.f d Z/e ,d ¡Z0e ,d!¡Z1e1e1d"d#d$Z2düd%ej3ej4e5e6f ej3ej-ej.gej.f ej3ej. ej-ej.gej.f d&d'd(Z7dýd%ej3ej4e5e6f ej3ej-ej.gej.f ej-ej.gej8ej. f d)d*d+Z9ej3ej4e5e6f ej8ej4e5e6f d,d-d.Z:d/e d"d0d1Z;ej4e5ej<e5ej.f ej=ej>e5ej.f f e5d"d2d3Z?e dþd4e5e5e5ej3e6 e5d5d6d7Z@e5e5d8d9d:ZAe5e5d8d;d<ZBej4ej<e0e1f ef ejCej>e0e1f d"d=d>ZDe dÿd4ej<e5ej.f eEe5d@dAdBZFe5e5d8dCdDZGe HdE¡ZIe5e5d8dFdGZJd ej<e0e1f eEdJeEej8ej>e0e1f dKdLdMZKedd%dNeEeEej3ej4e5e6f dOdPdQdRZLedd%dNeEej3ej4e5e6f dSdTdUdVZMd%dNdWeEej3ej4e5e6f dXdYdZd[ZNedd%dNeEej3ej4e5e6f dXdTd\d]ZOedd%dNeEej3ej4e5e6f dXdTd^d_ZPde1e1eEe1dadbdcZQe dd4ej=e5ej3ej4e5e6f e5dddedfZReeRdd4ej4ejSej=f e5ej3ej4e5e6f e5dddgdhZTde5e6e5djdkdlZUed%dNdXdmdndoZVeeVd%dpdXdmdqdrZWed%dsdXdmdtduZXedvdwdXdxdydzZYd ej4e5eZe6f eEe5d{d|d}Z[ej.e5d"d~dZ\e Hd¡Z]e d
|
d4e5ej3e6 eEej3e5 ej3e5 ej3ej=e5 e5dddZ^d e5ej4e6e5f eEeEe5d
ddZ_ed d%e5e6eEe5ej3e6 e5dddZ`ed d%e5e6eEej3e5 eEe5dddZae Hd¡Zbe5e6d8ddZcdej.e6e6e6dddZddej.eZeZdddZee5ej.ej.e5dddZfde5ej3e5 e5dd d¡Zgd/e5d"d¢d£Zhdd¤e6d¥d¦d§d¨d©Zieeiddpe6ej3ej. d¦d§dªd«ZjddNe6d¥d¦d¬dd®ZkdeZe6d°eZd±d²d³ZlG d´dµ dµejmZnedd%dNej4e5e6f ej3ej. eEd¶d·d¸d¹Zoeeodd%dpej4e5e6f ej3ej. eEd¶d·dºd»Zpedd%dNej3ej4e5e6f e1e1d¼d½d¾Zqeeqdd%dpej3ej4e5e6f e1e1d¼d¿dÀZrdNdOd"dÁdÂZseesdpdOd"dÃdÄZte5e d"dÅdÆZue5e5d"dÇdÈZvejwe5e5d"dÉdÊZxejwdNdNd"dËdÊZxej4e5ej=e1 f ej4e5ej=e1 f d"dÌdÊZxed%ej.e5ej4eej.f dÍdÎdÏZyejwdvej=e5ej.ej.ej=dÐdÑdÒZzejwd ddÓdvej=e5ej3ej. ej=dÔdÕdÒZzedvej=ej.ej.ej=dÖd×dÒZzejwdvej4ejSej=f e5ej.ej.ej=dÐdØdÙZ{ejwd ddÓdvej4ejSej=f e5ej3ej. ej=dÔdÚdÙZ{eezdvej4ejSej=f ej.ej.ejSdÖdÛdÙZ{edvdNej.ej.dSdÖdÜdÝZ|ee|dvdpej.ej.dÞdÖdßdàZ}edvdNej.ej.dSdÖdádâZ~ee~dvdpej.ej.dÞdÖdãdäZedvdNej.ej.dSdÖdådæZeedvdpej.ej.dÞdÖdçdèZedvdNej.ej.dSdÖdédêZeedvdpej.ej.dÞdÖdëdìZe dd4ej.ej3e6 e dídîdïZdvej>ej
e5ej.f ej-ej.gej.f dðdñdòZdvej>ej
e5ej.f ej-ej.gej.f eEej-ej.gej.f dódôdõZdvdNej>ej
e5ej.f ej-ej.gej.f eEdSdöd÷døZdvdpej>ej
e5ej.f ej-ej.gej.f eEdÞdödùdúZeeyekeGeUeeQeQeKe e e[eWeee;efepe_edeTeXeeteBeDe{eOePe\eYeee@exeleue}eejeLeehereJege`eMeAe?e^eceaeFedû6ZdS ( z7Built-in template filters used with the ``|`` operator.é N)Úabc)Úchain)Úgroupby)Úescape©ÚMarkup)Úsoft_stré )Ú async_variant)Ú
|
auto_aiter)Ú
|
auto_await©Ú auto_to_list)ÚFilterArgumentError)Ú Undefined)Úhtmlsafe_json_dumps)Ú pass_context)Úpass_environment)Úpass_eval_context©Úpformat©Ú url_quote)Úurlize)Ú Environment)Ú EvalContext)ÚContext)ÚSandboxedEnvironmentc @ s e Zd ZedddZdS )ÚHasHTML©Úreturnc C s d S ©N© ©Úselfr" r" úEd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\jinja2/filters.pyÚ__html__% s zHasHTML.__html__N)Ú__name__Ú
|
__module__Ú __qualname__Ústrr& r" r" r" r% r $ s r ÚF.)ÚboundÚKÚV)Úvaluer c C s t | trt t| ¡ ¡S | S )zxFor use as a postprocessor for :func:`make_attrgetter`. Converts strings
|
to lowercase and returns other types as-is.)Ú
|
isinstancer* ÚtÚcastr. Úlower©r/ r" r" r% Ú ignore_case. s
|
r5 r )Ú environmentÚ attributeÚ postprocessÚdefaultr c s* t |tjtjd fdd }|S )zæReturns a callable that looks up the given attribute from a
|
passed object with the rules of the environment. Dots are allowed
|
to access attributes of attributes. Integer parts in paths are
|
looked up as integers.
|
©Úitemr c s@ D ]&} | |¡} d k rt| tr } qd k r<| } | S r! )Úgetitemr0 r )r; Úpart©r9 r6 Úpartsr8 r" r% Ú
|
attrgetterD s z#make_attrgetter.<locals>.attrgetter)Ú_prepare_attribute_partsr1 ÚAny)r6 r7 r8 r9 r@ r" r> r% Úmake_attrgetter7 s rC )r6 r7 r8 r c sP t |tr| d¡}n|g}dd |D tjtjtj d fdd }|S )a© Returns a callable that looks up the given comma separated
|
attributes from a passed object with the rules of the environment.
|
Dots are allowed to access attributes of each attribute. Integer
|
parts in paths are looked up as integers.
|
|
The value returned by the returned callable is a list of extracted
|
attribute values.
|
|
Examples of attribute: "attr1,attr2", "attr1.inner1.0,attr2.inner2.0", etc.
|
ú,c S s g | ] }t |qS r" )rA ©Ú.0r; r" r" r% Ú
|
<listcomp>g s z)make_multi_attrgetter.<locals>.<listcomp>r: c sV d gt }tD ]:\}}| }|D ]} ||¡}q&d k rH|}|||< q|S r! )ÚlenÚ enumerater< )r; ÚitemsÚiZattribute_partZitem_ir= ©r6 r? r8 r" r% r@ i s
|
z)make_multi_attrgetter.<locals>.attrgetter)r0 r* Úsplitr1 rB ÚList)r6 r7 r8 rM r@ r" rL r% Úmake_multi_attrgetterS s
|
"rO )Úattrr c C s0 | d kr g S t | tr*dd | d¡D S | gS )Nc S s g | ]}| ¡ rt|n|qS r" )ÚisdigitÚint)rF Úxr" r" r% rG s z,_prepare_attribute_parts.<locals>.<listcomp>Ú.)r0 r* rM )rP r" r" r% rA | s
|
|
rA zt.Union[str, HasHTML]c C s& t | drt d| ¡ ¡ } tt| S )zCEnforce HTML escaping. This will probably double escape variables.r& r )Úhasattrr1 r2 r& r r* r4 r" r" r% Údo_forceescape s
|
rV c C sJ t | tst | tjs t| S t | tr2| ¡ }n| }d dd |D ¡S )a3 Quote data for use in a URL path or query using UTF-8.
|
|
Basic wrapper around :func:`urllib.parse.quote` when given a
|
string, or :func:`urllib.parse.urlencode` for a dict or iterable.
|
|
:param value: Data to quote. A string will be quoted directly. A
|
dict or iterable of ``(key, value)`` pairs will be joined as a
|
query string.
|
|
When given a string, "/" is not quoted. HTTP servers treat "/" and
|
"%2F" equivalently in paths. If you need quoted slashes, use the
|
``|replace("/", "%2F")`` filter.
|
|
.. versionadded:: 2.7
|
ú&c s s0 | ](\}}t |d d dt |d d V qdS )T)Zfor_qsú=Nr )rF ÚkÚvr" r" r% Ú <genexpr>ª s z do_urlencode.<locals>.<genexpr>)r0 r* r ÚIterabler ÚdictrJ Újoin)r/ rJ r" r" r% Ú do_urlencode s
|
|
|
ÿr_ r )Úeval_ctxÚsÚoldÚnewÚcountr c C sr |dkr d}| j s,t| t|t||¡S t|dsJt|drTt|dsTt|}nt|}| t|t||¡S )aü Return a copy of the value with all occurrences of a substring
|
replaced with a new one. The first argument is the substring
|
that should be replaced, the second is the replacement string.
|
If the optional third argument ``count`` is given, only the first
|
``count`` occurrences are replaced:
|
|
.. sourcecode:: jinja
|
|
{{ "Hello World"|replace("Hello", "Goodbye") }}
|
-> Goodbye World
|
|
{{ "aaaaargh"|replace("a", "d'oh, ", 2) }}
|
-> d'oh, d'oh, aaargh
|
Néÿÿÿÿr& )Ú
|
autoescaper* ÚreplacerU r r )r` ra rb rc rd r" r" r% Ú
|
do_replace¯ s ÿþý
|
rh )ra r c C s t | ¡ S )z Convert a value to uppercase.)r Úupper©ra r" r" r% Údo_upperÓ s rk c C s t | ¡ S )z Convert a value to lowercase.)r r3 rj r" r" r% Údo_lowerØ s rl c c s4 t | trdS t | tjs"td| ¡ E dH dS )aO Return an iterator over the ``(key, value)`` items of a mapping.
|
|
``x|items`` is the same as ``x.items()``, except if ``x`` is
|
undefined an empty iterator is returned.
|
|
This filter is useful if you expect the template to be rendered with
|
an implementation of Jinja in another programming language that does
|
not have a ``.items()`` method on its mapping type.
|
|
.. code-block:: html+jinja
|
|
<dl>
|
{% for key, value in my_dict|items %}
|
<dt>{{ key }}
|
<dd>{{ value }}
|
{% endfor %}
|
</dl>
|
|
.. versionadded:: 3.1
|
Nz'Can only get item pairs from a mapping.)r0 r r ÚMappingÚ TypeErrorrJ r4 r" r" r% Údo_itemsÝ s
|
|
ro T)r` ÚdÚ autospacer c C s: d dd | ¡ D ¡}|r(|r(d| }| jr6t|}|S )ac Create an SGML/XML attribute string based on the items in a dict.
|
All values that are neither `none` nor `undefined` are automatically
|
escaped:
|
|
.. sourcecode:: html+jinja
|
|
<ul{{ {'class': 'my_list', 'missing': none,
|
'id': 'list-%d'|format(variable)}|xmlattr }}>
|
...
|
</ul>
|
|
Results in something like this:
|
|
.. sourcecode:: html
|
|
<ul class="my_list" id="list-42">
|
...
|
</ul>
|
|
As you can see it automatically prepends a space in front of the item
|
if the filter returned something unless the second parameter is false.
|
ú c s s< | ]4\}}|d k rt |tst| dt| dV qd S )Nz="ú")r0 r r )rF Úkeyr/ r" r" r% r[ s
|
þz do_xmlattr.<locals>.<genexpr>)r^ rJ rf r )r` rp rq Úrvr" r" r% Ú
|
do_xmlattrû s
|
þrv c C s t | ¡ S )zYCapitalize a value. The first character will be uppercase, all others
|
lowercase.
|
)r Ú
|
capitalizerj r" r" r% Ú do_capitalize$ s rx z ([-\s({\[<]+)c C s d dd t t| ¡D ¡S )zReturn a titlecased version of the value. I.e. words will start with
|
uppercase letters, all remaining characters are lowercase.
|
Ú c S s, g | ]$}|r|d ¡ |dd
¡ qS )r r N)ri r3 rE r" r" r% rG 3 s þz do_title.<locals>.<listcomp>)r^ Ú_word_beginning_split_rerM r rj r" r" r% Údo_title. s
|
þÿr{ Frt zte.Literal["key", "value"])r/ Úcase_sensitiveÚbyÚreverser c s\ |dkrdn|dkr dnt dtjtjtjf tjd fdd }t| ¡ ||d S )
|
af Sort a dict and yield (key, value) pairs. Python dicts may not
|
be in the order you want to display them in, so sort them first.
|
|
.. sourcecode:: jinja
|
|
{% for key, value in mydict|dictsort %}
|
sort the dict by key, case insensitive
|
|
{% for key, value in mydict|dictsort(reverse=true) %}
|
sort the dict by key, case insensitive, reverse order
|
|
{% for key, value in mydict|dictsort(true) %}
|
sort the dict by key, case sensitive
|
|
{% for key, value in mydict|dictsort(false, 'value') %}
|
sort the dict by value, case insensitive
|
rt r r/ r z,You can only sort by either "key" or "value"r: c s | } st |}|S r! )r5 )r; r/ ©r| Úposr" r% Ú sort_funcY s z do_dictsort.<locals>.sort_func©rt r~ )r r1 ÚTuplerB ÚsortedrJ )r/ r| r} r~ r r" r r% Ú do_dictsort; s &r
z t.Iterable[V]z t.List[V])r6 r/ r~ r| r7 r c C s$ t | ||stndd}t|||dS )a- Sort an iterable using Python's :func:`sorted`.
|
|
.. sourcecode:: jinja
|
|
{% for city in cities|sort %}
|
...
|
{% endfor %}
|
|
:param reverse: Sort descending instead of ascending.
|
:param case_sensitive: When sorting strings, sort upper and lower
|
case separately.
|
:param attribute: When sorting objects or dicts, an attribute or
|
key to sort by. Can use dot notation like ``"address.city"``.
|
Can be a list of attributes like ``"age,name"``.
|
|
The sort is stable, it does not change the relative order of
|
elements that compare equal. This makes it is possible to chain
|
sorts on different attributes and ordering.
|
|
.. sourcecode:: jinja
|
|
{% for user in users|sort(attribute="name")
|
|sort(reverse=true, attribute="age") %}
|
...
|
{% endfor %}
|
|
As a shortcut to chaining when the direction is the same for all
|
attributes, pass a comma separate list of attributes.
|
|
.. sourcecode:: jinja
|
|
{% for user in users|sort(attribute="age,name") %}
|
...
|
{% endfor %}
|
|
.. versionchanged:: 2.11.0
|
The ``attribute`` parameter can be a comma separated list of
|
attributes, e.g. ``"age,name"``.
|
|
.. versionchanged:: 2.6
|
The ``attribute`` parameter was added.
|
N©r8 r )rO r5 r )r6 r/ r~ r| r7 Úkey_funcr" r" r% Údo_sortd s 2
|
ÿr z t.Iterator[V])r6 r/ r| r7 r c c sJ t | ||stndd}t }|D ]$}||}||kr | |¡ |V q dS )aÍ Returns a list of unique items from the given iterable.
|
|
.. sourcecode:: jinja
|
|
{{ ['foo', 'bar', 'foobar', 'FooBar']|unique|list }}
|
-> ['foo', 'bar', 'foobar']
|
|
The unique items are yielded in the same order as their first occurrence in
|
the iterable passed to the filter.
|
|
:param case_sensitive: Treat upper and lower case strings as distinct.
|
:param attribute: Filter objects with unique values for this attribute.
|
Nr )rC r5 ÚsetÚadd)r6 r/ r| r7 ÚgetterÚseenr; rt r" r" r% Ú do_unique s
|
ÿ
|
r zt.Callable[..., V]zt.Union[V, Undefined])r6 r/ Úfuncr| r7 r c C s^ t |}z t|}W n tk
|
r2 | d¡ Y S X t| ||sBtnd d}|t|g||dS )Nz'No aggregated item, sequence was empty.r ©rt )ÚiterÚnextÚ StopIterationÚ undefinedrC r5 r )r6 r/ r r| r7 ÚitÚfirstr r" r" r% Ú _min_or_max½ s
|
ÿr c C s t | |t||S )a Return the smallest item from the sequence.
|
|
.. sourcecode:: jinja
|
|
{{ [1, 2, 3]|min }}
|
-> 1
|
|
:param case_sensitive: Treat upper and lower case strings as distinct.
|
:param attribute: Get the object with the min value of this attribute.
|
)r Úmin©r6 r/ r| r7 r" r" r% Údo_minÑ s r c C s t | |t||S )a Return the largest item from the sequence.
|
|
.. sourcecode:: jinja
|
|
{{ [1, 2, 3]|max }}
|
-> 3
|
|
:param case_sensitive: Treat upper and lower case strings as distinct.
|
:param attribute: Get the object with the max value of this attribute.
|
)r Úmaxr r" r" r% Údo_maxå s r ry )r/ Ú default_valueÚbooleanr c C s t | ts|r| s|S | S )a` If the value is undefined it will return the passed default value,
|
otherwise the value of the variable:
|
|
.. sourcecode:: jinja
|
|
{{ my_variable|default('my_variable is not defined') }}
|
|
This will output the value of ``my_variable`` if the variable was
|
defined, otherwise ``'my_variable is not defined'``. If you want
|
to use default with variables that evaluate to false you have to
|
set the second parameter to `true`:
|
|
.. sourcecode:: jinja
|
|
{{ ''|default('the string was empty', true) }}
|
|
.. versionchanged:: 2.11
|
It's now possible to configure the :class:`~jinja2.Environment` with
|
:class:`~jinja2.ChainableUndefined` to make the `default` filter work
|
on nested elements and attributes that may contain undefined values
|
in the chain without getting an :exc:`~jinja2.UndefinedError`.
|
)r0 r )r/ r r r" r" r% Ú
|
do_defaultù s r )r` r/ rp r7 r c C s¬ |dk rt t| j||}| js4t| t t|¡S t|dst|}d}t|D ]$\}}t|drjd}qRt|||< qR|rt |}nt|}| |¡S t
|
| t t
|
|¡S )a# Return a string which is the concatenation of the strings in the
|
sequence. The separator between elements is an empty string per
|
default, you can define it with the optional parameter:
|
|
.. sourcecode:: jinja
|
|
{{ [1, 2, 3]|join('|') }}
|
-> 1|2|3
|
|
{{ [1, 2, 3]|join }}
|
-> 123
|
|
It is also possible to join certain attributes of an object:
|
|
.. sourcecode:: jinja
|
|
{{ users|join(', ', attribute='username') }}
|
|
.. versionadded:: 2.6
|
The `attribute` parameter was added.
|
Nr& FT) ÚmaprC r6 rf r* r^ rU ÚlistrI r r )r` r/ rp r7 Z do_escapeÚidxr; r" r" r% Ú sync_do_join s
|
|
|
|
r¢ c à s t | t|I d H ||S r! )r¢ r )r` r/ rp r7 r" r" r% Údo_joinT s r£ éP )r/ Úwidthr c C s t | |¡S )z.Centers the value in a field of a given width.)r Úcenter)r/ r¥ r" r" r% Ú do_center^ s r§ )r6 Úseqr c C s2 zt t|W S tk
|
r, | d¡ Y S X dS )z$Return the first item of a sequence.ú"No first item, sequence was empty.N)r r r r ©r6 r¨ r" r" r% Ú sync_do_firstc s r« z*t.Union[t.AsyncIterable[V], t.Iterable[V]]c à s8 zt | ¡ I d H W S tk
|
r2 | d¡ Y S X d S )Nr© )r Ú __anext__ÚStopAsyncIterationr rª r" r" r% Údo_firstn s r® zt.Reversible[V]c C s6 zt tt|W S tk
|
r0 | d¡ Y S X dS )zèReturn the last item of a sequence.
|
|
Note: Does not work with generators. You may want to explicitly
|
convert it to a list:
|
|
.. sourcecode:: jinja
|
|
{{ data | selectattr('name', '==', 'Jinja') | list | last }}
|
z!No last item, sequence was empty.N)r r Úreversedr r rª r" r" r% Údo_lastx s r° r z t.Sequence[V])Úcontextr¨ r c C s2 z t |¡W S tk
|
r, | j d¡ Y S X dS )z'Return a random item from the sequence.z#No random item, sequence was empty.N)ÚrandomÚchoiceÚ
|
IndexErrorr6 r )r± r¨ r" r" r% Ú do_random s rµ )r/ Úbinaryr c C sè t | }|rdnd}|r dnd|r&dnd|r0dnd|r:d nd
|
|rDd nd |rNd nd|rXdnd|rbdndg}|dkrtdS ||k rt| dS t|D ]8\}}||d }||k r|| | dd| S q|| | dd| S dS )zøFormat the value like a 'human-readable' file size (i.e. 13 kB,
|
4.1 MB, 102 Bytes, etc). Per default decimal prefixes are used (Mega,
|
Giga, etc.), if the second parameter is set to `True` the binary
|
prefixes are used (Mebi, Gibi).
|
i iè ZKiBZkBZMiBZMBZGiBZGBZTiBZTBZPiBZPBZEiBZEBZZiBZZBZYiBZYBr z1 Bytez Bytesé z.1frr N)ÚfloatrR rI )r/ r¶ ÚbytesÚbaseÚprefixesrK ÚprefixÚunitr" r" r% Údo_filesizeformat s(
|
|
|
|
|
|
|
|
ø r¾ c C s t | S )z.Pretty print a variable. Useful for debugging.r r4 r" r" r% Ú do_pprint¸ s r¿ z^([\w.+-]{2,}:(/){0,2})$)r` r/ Útrim_url_limitÚnofollowÚtargetÚrelÚ extra_schemesr c C s¼ | j j}t|pd ¡ }|r&| d¡ | |d p4d ¡ ¡ d t|¡pLd}|dkr^|d }|dkrr|d ppd}|D ] } t | ¡dkrvt
|
| d qvt |||||d
|
}
|
| j r¸t |
|
}
|
|
|
S ) a0 Convert URLs in text into clickable links.
|
|
This may not recognize links in some situations. Usually, a more
|
comprehensive formatter, such as a Markdown library, is a better
|
choice.
|
|
Works on ``http://``, ``https://``, ``www.``, ``mailto:``, and email
|
addresses. Links with trailing punctuation (periods, commas, closing
|
parentheses) and leading punctuation (opening parentheses) are
|
recognized excluding the punctuation. Email addresses that include
|
header fields are not recognized (for example,
|
``mailto:address@example.com?cc=copy@example.com``).
|
|
:param value: Original text containing URLs to link.
|
:param trim_url_limit: Shorten displayed URL values to this length.
|
:param nofollow: Add the ``rel=nofollow`` attribute to links.
|
:param target: Add the ``target`` attribute to links.
|
:param rel: Add the ``rel`` attribute to links.
|
:param extra_schemes: Recognize URLs that start with these schemes
|
in addition to the default behavior. Defaults to
|
``env.policies["urlize.extra_schemes"]``, which defaults to no
|
extra schemes.
|
|
.. versionchanged:: 3.0
|
The ``extra_schemes`` parameter was added.
|
|
.. versionchanged:: 3.0
|
Generate ``https://`` links for URLs without a scheme.
|
|
.. versionchanged:: 3.0
|
The parsing rules were updated. Recognize email addresses with
|
or without the ``mailto:`` scheme. Validate IP addresses. Ignore
|
parentheses and brackets in more cases.
|
|
.. versionchanged:: 2.8
|
The ``target`` parameter was added.
|
ry rÁ z
|
urlize.relrr Nz urlize.targetzurlize.extra_schemesr" z" is not a valid URI scheme prefix.)rÀ rà r rÄ )r6 Úpoliciesr rM r Úupdater^ r Ú_uri_scheme_reÚ fullmatchr r rf r ) r` r/ rÀ rÁ r rà rÄ rÅ Z rel_partsÚschemeru r" r" r% Ú do_urlizeÀ s. /
|
ûrÊ é )ra r¥ r Úblankr c s t |tr| nd| d}t | tr6t t|}| |7 } |rV| | ¡ ¡}n6| ¡ }| d¡}|r||| fdd|D ¡ 7 }|r | }|S )aú Return a copy of the string with each line indented by 4 spaces. The
|
first line and blank lines are not indented by default.
|
|
:param width: Number of spaces, or a string, to indent by.
|
:param first: Don't skip indenting the first line.
|
:param blank: Don't skip indenting empty lines.
|
|
.. versionchanged:: 3.0
|
``width`` can be a string.
|
|
.. versionchanged:: 2.10
|
Blank lines are not indented by default.
|
|
Rename the ``indentfirst`` argument to ``first``.
|
rr Ú
|
r c 3 s | ]}|r | n|V qd S r! r" ©rF Úline©Z indentionr" r% r[ 6 s z do_indent.<locals>.<genexpr>)r0 r* r r^ Ú
|
splitlinesÚpop)ra r¥ r rÌ Únewlineru Úlinesr" rÐ r% Ú do_indent s&
|
|
|
ÿ rÕ éÿ ú...)Úenvra ÚlengthÚ killwordsÚendÚleewayr c C s¤ |dkr| j d }|t|ks6tdt| d| |dksLtd| t||| kr`|S |r||d|t|
| S |d|t|
dd¡d }|| S ) aì Return a truncated copy of the string. The length is specified
|
with the first parameter which defaults to ``255``. If the second
|
parameter is ``true`` the filter will cut the text at length. Otherwise
|
it will discard the last word. If the text was in fact
|
truncated it will append an ellipsis sign (``"..."``). If you want a
|
different ellipsis sign than ``"..."`` you can specify it using the
|
third parameter. Strings that only exceed the length by the tolerance
|
margin given in the fourth parameter will not be truncated.
|
|
.. sourcecode:: jinja
|
|
{{ "foo bar baz qux"|truncate(9) }}
|
-> "foo..."
|
{{ "foo bar baz qux"|truncate(9, True) }}
|
-> "foo ba..."
|
{{ "foo bar baz qux"|truncate(11) }}
|
-> "foo bar baz qux"
|
{{ "foo bar baz qux"|truncate(11, False, '...', 0) }}
|
-> "foo bar..."
|
|
The default leeway on newer Jinja versions is 5 and was 0 before but
|
can be reconfigured globally.
|
Nztruncate.leewayzexpected length >= z, got r zexpected leeway >= 0, got rr r )rÅ rH ÚAssertionErrorÚrsplit)rØ ra rÙ rÚ rÛ rÜ Úresultr" r" r% Ú do_truncate@ s
|
$ rà éO )r6 ra r¥ Úbreak_long_wordsÚ
|
wrapstringÚbreak_on_hyphensr c s: ddl dkr| j fdd| ¡ D ¡S )aú Wrap a string to the given width. Existing newlines are treated
|
as paragraphs to be wrapped separately.
|
|
:param s: Original text to wrap.
|
:param width: Maximum length of wrapped lines.
|
:param break_long_words: If a word is longer than ``width``, break
|
it across lines.
|
:param break_on_hyphens: If a word contains hyphens, it may be split
|
across lines.
|
:param wrapstring: String to join each wrapped line. Defaults to
|
:attr:`Environment.newline_sequence`.
|
|
.. versionchanged:: 2.11
|
Existing newlines are treated as paragraphs wrapped separately.
|
|
.. versionchanged:: 2.11
|
Added the ``break_on_hyphens`` parameter.
|
|
.. versionchanged:: 2.7
|
Added the ``wrapstring`` parameter.
|
r Nc s( g | ] } j|d d d¡qS )F)r¥ Ú expand_tabsÚreplace_whitespacerâ rä )r^ ÚwraprÎ ©râ rä Útextwrapr¥ rã r" r% rG s öúÿz do_wordwrap.<locals>.<listcomp>)ré Znewline_sequencer^ rÑ )r6 ra r¥ râ rã rä r" rè r% Ú do_wordwrapp s õÿrê z\w+c C s t t t| ¡S )z Count the words in that string.)rH Ú_word_reÚfindallr rj r" r" r% Ú do_wordcount« s rí é
|
)r/ r9 rº r c C sr z t | trt| |W S t| W S ttfk
|
rl ztt| W Y S ttfk
|
rf | Y Y S X Y nX dS )a Convert the value into an integer. If the
|
conversion doesn't work it will return ``0``. You can
|
override this default using the first parameter. You
|
can also override the default base (10) in the second
|
parameter, which handles input with prefixes such as
|
0b, 0o and 0x for bases 2, 8 and 16 respectively.
|
The base is ignored for decimal numbers and non-string values.
|
N)r0 r* rR rn Ú
|
ValueErrorr¸ )r/ r9 rº r" r" r% Údo_int° s
|
|
rð ç )r/ r9 r c C s, z
|
t | W S ttfk
|
r& | Y S X dS )z¬Convert the value into a floating point number. If the
|
conversion doesn't work it will return ``0.0``. You can
|
override this default using the first parameter.
|
N)r¸ rn rï )r/ r9 r" r" r% Údo_floatÆ s
|
rò )r/ ÚargsÚkwargsr c O s |r|rt dt| |p | S )a Apply the given values to a `printf-style`_ format string, like
|
``string % values``.
|
|
.. sourcecode:: jinja
|
|
{{ "%s, %s!"|format(greeting, name) }}
|
Hello, World!
|
|
In most cases it should be more convenient and efficient to use the
|
``%`` operator or :meth:`str.format`.
|
|
.. code-block:: text
|
|
{{ "%s, %s!" % (greeting, name) }}
|
{{ "{}, {}!".format(greeting, name) }}
|
|
.. _printf-style: https://docs.python.org/library/stdtypes.html
|
#printf-style-string-formatting
|
z>can't handle positional and keyword arguments at the same time)r r )r/ ró rô r" r" r% Ú do_formatÑ s
|
ÿrõ )r/ Úcharsr c C s t | |¡S )z=Strip leading and trailing characters, by default whitespace.)r Ústrip)r/ rö r" r" r% Údo_trimí s rø c C s* t | drt d| ¡ ¡ } tt| ¡ S )zAStrip SGML/XML tags and replace adjacent whitespace by one space.r& r )rU r1 r2 r& r r* Ú striptagsr4 r" r" r% Ú do_striptagsò s
|
rú zt.Collection[V]z t.Optional[V]zt.Iterator[t.List[V]])r/ ÚslicesÚ fill_withr c c s t | }t|}|| }|| }d}t|D ]\}||| } ||k rL|d7 }||d | }
|
|| |
|
} |dk r||kr| |¡ | V q,dS )aF Slice an iterator and return a list of lists containing
|
those items. Useful if you want to create a div containing
|
three ul tags that represent columns:
|
|
.. sourcecode:: html+jinja
|
|
<div class="columnwrapper">
|
{%- for column in items|slice(3) %}
|
<ul class="column-{{ loop.index }}">
|
{%- for item in column %}
|
<li>{{ item }}</li>
|
{%- endfor %}
|
</ul>
|
{%- endfor %}
|
</div>
|
|
If you pass it a second argument it's used to fill missing
|
values on the last iteration.
|
r r N)r rH ÚrangeÚappend) r/ rû rü r¨ rÙ Zitems_per_sliceZslices_with_extraÚoffsetZ slice_numberÚstartrÛ Útmpr" r" r% Ú sync_do_sliceú s
|
r c à s t t| I d H ||S r! )r r )r/ rû rü r" r" r% Údo_slice% s r )r/ Ú linecountrü r c c sf g }| D ]$}t ||kr"|V g }| |¡ q|rb|dk r\t ||k r\||g|t | 7 }|V dS )a
|
A filter that batches items. It works pretty much like `slice`
|
just the other way round. It returns a list of lists with the
|
given number of items. If you provide a second parameter this
|
is used to fill up missing items. See this example:
|
|
.. sourcecode:: html+jinja
|
|
<table>
|
{%- for row in items|batch(3, ' ') %}
|
<tr>
|
{%- for column in row %}
|
<td>{{ column }}</td>
|
{%- endfor %}
|
</tr>
|
{%- endfor %}
|
</table>
|
N)rH rþ )r/ r rü r r; r" r" r% Údo_batch. s r Úcommonz%te.Literal["common", "ceil", "floor"])r/ Ú precisionÚmethodr c C sL |dkrt d|dkr"t| |S tt|}t t|| d| d| ¡S )a Round the number to a given precision. The first
|
parameter specifies the precision (default is ``0``), the
|
second the rounding method:
|
|
- ``'common'`` rounds either up or down
|
- ``'ceil'`` always rounds up
|
- ``'floor'`` always rounds down
|
|
If you don't specify a method ``'common'`` is used.
|
|
.. sourcecode:: jinja
|
|
{{ 42.55|round }}
|
-> 43.0
|
{{ 42.55|round(1, 'floor') }}
|
-> 42.5
|
|
Note that even if rounded to 0 precision, a float is returned. If
|
you need a real integer, pipe it through `int`:
|
|
.. sourcecode:: jinja
|
|
{{ 42.55|round|int }}
|
-> 43
|
> ÚfloorÚceilr z$method must be common, ceil or floorr rî )r ÚroundÚgetattrÚmathr1 r2 r¸ )r/ r r r r" r" r% Údo_roundS s
|
|
r c @ s> e Zd ZU ejed< ejed< edddZedddZ dS ) Ú _GroupTupleZgrouperr r c C s
|
t | ¡S r! )ÚtupleÚ__repr__r# r" r" r% r s z_GroupTuple.__repr__c C s
|
t | ¡S r! )r Ú__str__r# r" r" r% r s z_GroupTuple.__str__N)
|
r' r( r) r1 rB Ú__annotations__rN r* r r r" r" r" r% r { s
|
|
|
r zt.List[_GroupTuple])r6 r/ r7 r9 r| r c s\ t | ||stnd|d}dd tt||d|D }|sXt | ||d fdd|D }|S )aq Group a sequence of objects by an attribute using Python's
|
:func:`itertools.groupby`. The attribute can use dot notation for
|
nested access, like ``"address.city"``. Unlike Python's ``groupby``,
|
the values are sorted first so only one group is returned for each
|
unique value.
|
|
For example, a list of ``User`` objects with a ``city`` attribute
|
can be rendered in groups. In this example, ``grouper`` refers to
|
the ``city`` value of the group.
|
|
.. sourcecode:: html+jinja
|
|
<ul>{% for city, items in users|groupby("city") %}
|
<li>{{ city }}
|
<ul>{% for user in items %}
|
<li>{{ user.name }}
|
{% endfor %}</ul>
|
</li>
|
{% endfor %}</ul>
|
|
``groupby`` yields namedtuples of ``(grouper, list)``, which
|
can be used instead of the tuple unpacking above. ``grouper`` is the
|
value of the attribute, and ``list`` is the items with that value.
|
|
.. sourcecode:: html+jinja
|
|
<ul>{% for group in users|groupby("city") %}
|
<li>{{ group.grouper }}: {{ group.list|join(", ") }}
|
{% endfor %}</ul>
|
|
You can specify a ``default`` value to use if an object in the list
|
does not have the given attribute.
|
|
.. sourcecode:: jinja
|
|
<ul>{% for city, items in users|groupby("city", default="NY") %}
|
<li>{{ city }}: {{ items|map(attribute="name")|join(", ") }}</li>
|
{% endfor %}</ul>
|
|
Like the :func:`~jinja-filters.sort` filter, sorting and grouping is
|
case-insensitive by default. The ``key`` for each group will have
|
the case of the first item in that group of values. For example, if
|
a list of users has cities ``["CA", "NY", "ca"]``, the "CA" group
|
will have two values. This can be disabled by passing
|
``case_sensitive=True``.
|
|
.. versionchanged:: 3.1
|
Added the ``case_sensitive`` parameter. Sorting and grouping is
|
case-insensitive by default, matching other filters that do
|
comparisons.
|
|
.. versionchanged:: 3.0
|
Added the ``default`` parameter.
|
|
.. versionchanged:: 2.6
|
The attribute supports dot notation for nested access.
|
N©r8 r9 c S s g | ]\}}t |t|qS r" )r r ©rF rt Úvaluesr" r" r% rG Ï s ÿz#sync_do_groupby.<locals>.<listcomp>r ©r9 c s" g | ]\}}t |d |qS ©r ©r ©rF Ú_r ©Z output_exprr" r% rG × s )rC r5 r r ©r6 r/ r7 r9 r| ÚexprÚoutr" r r% Úsync_do_groupby s A
|
üþr c sl t | ||stnd |d}dd ttt|I d H |d|D I d H }|sht | ||d fdd|D }|S )Nr c Ó s$ g | ] \}}t |t|I d H qS r! )r r r r" r" r% rG ê s ÿz do_groupby.<locals>.<listcomp>r r c s" g | ]\}}t |d |qS r r r r r" r% rG ò s )rC r5 r r r r r" r r% Ú
|
do_groupbyÜ s
|
üþ r! )r6 Úiterabler7 r r c C s" |dk rt t| ||}t||S )a× Returns the sum of a sequence of numbers plus the value of parameter
|
'start' (which defaults to 0). When the sequence is empty it returns
|
start.
|
|
It is also possible to sum up only certain attributes:
|
|
.. sourcecode:: jinja
|
|
Total: {{ items|sum(attribute='price') }}
|
|
.. versionchanged:: 2.6
|
The ``attribute`` parameter was added to allow summing up over
|
attributes. Also the ``start`` parameter was moved on to the right.
|
N)r rC Úsum)r6 r" r7 r r" r" r% Ú sync_do_sum÷ s r$ c à sP |}|d k rt | |}nttddd}t|2 z3 d H W }|||7 }q06 |S )N©rS r c S s | S r! r" ©rS r" r" r% r s zdo_sum.<locals>.func)rC r. r )r6 r" r7 r ru r r; r" r" r% Údo_sum s r' c C s t | S )zkConvert the value into a list. If it was a string the returned list
|
will be a list of characters.
|
)r r4 r" r" r% Ú sync_do_list( s r( c à s t | I d H S r! r r4 r" r" r% Údo_list/ s r) c C s t | S )z
Mark the value as safe which means that in an environment with automatic
|
escaping enabled this variable will not be escaped.
|
r r4 r" r" r% Ú do_mark_safe4 s r* c C s t | S )zHMark a value as unsafe. This is the reverse operation for :func:`safe`.)r* r4 r" r" r% Údo_mark_unsafe; s r+ c C s d S r! r" r4 r" r" r% Ú
|
do_reverse@ s r, c C s d S r! r" r4 r" r" r% r, E s c C s t | tr| ddd
S z
|
t| W S tk
|
r~ zt| }| ¡ |W Y S tk
|
rx } ztd|W 5 d}~X Y nX Y nX dS )z\Reverse the object or return an iterator that iterates over it the other
|
way round.
|
Nre zargument must be iterable)r0 r* r¯ rn r r~ r )r/ ru Úer" r" r% r, J s
|
|
|
)r6 ÚobjÚnamer c C s z t |}W n tk
|
r Y nVX zt||}W n tk
|
rD Y n2X | jrrt d| ¡} | |||¡sr| ||¡S |S | j ||dS )zðGet an attribute of an object. ``foo|attr("bar")`` works like
|
``foo.bar`` just that always an attribute is returned and items are not
|
looked up.
|
|
See :ref:`Notes on subscriptions <notes-on-subscriptions>` for more details.
|
r )r. r/ )
|
r* Ú UnicodeErrorr ÚAttributeErrorZ sandboxedr1 r2 Zis_safe_attributeZunsafe_undefinedr )r6 r. r/ r/ r" r" r% Údo_attr\ s
|
r2 )r± r/ r/ ró rô r c O s d S r! r" ©r± r/ r/ ró rô r" r" r% Ú sync_do_map{ s r4 )r7 r9 )r± r/ r7 r9 r c C s d S r! r" ©r± r/ r7 r9 r" r" r% r4 s )r± r/ ró rô r c o s( |r$t | ||}|D ]}||V qdS )aé Applies a filter on a sequence of objects or looks up an attribute.
|
This is useful when dealing with lists of objects but you are really
|
only interested in a certain value of it.
|
|
The basic usage is mapping on an attribute. Imagine you have a list
|
of users but you are only interested in a list of usernames:
|
|
.. sourcecode:: jinja
|
|
Users on this page: {{ users|map(attribute='username')|join(', ') }}
|
|
You can specify a ``default`` value to use if an object in the list
|
does not have the given attribute.
|
|
.. sourcecode:: jinja
|
|
{{ users|map(attribute="username", default="Anonymous")|join(", ") }}
|
|
Alternatively you can let it invoke a filter by passing the name of the
|
filter and the arguments afterwards. A good example would be applying a
|
text conversion filter on a sequence:
|
|
.. sourcecode:: jinja
|
|
Users on this page: {{ titles|map('lower')|join(', ') }}
|
|
Similar to a generator comprehension such as:
|
|
.. code-block:: python
|
|
(u.username for u in users)
|
(getattr(u, "username", "Anonymous") for u in users)
|
(do_lower(x) for x in titles)
|
|
.. versionchanged:: 2.11.0
|
Added the ``default`` parameter.
|
|
.. versionadded:: 2.7
|
N)Ú prepare_map©r± r/ ró rô r r; r" r" r% r4 s + c O s d S r! r" r3 r" r" r% Údo_map¿ s r8 c C s d S r! r" r5 r" r" r% r8 Ê s c O s@ |r<t | ||}t|2 z 3 d H W }t||I d H V q6 d S r! )r6 r r r7 r" r" r% r8 Õ s c O s t | |||dd dS )a¢ Filters a sequence of objects by applying a test to each object,
|
and only selecting the objects with the test succeeding.
|
|
If no test is specified, each object will be evaluated as a boolean.
|
|
Example usage:
|
|
.. sourcecode:: jinja
|
|
{{ numbers|select("odd") }}
|
{{ numbers|select("odd") }}
|
{{ numbers|select("divisibleby", 3) }}
|
{{ numbers|select("lessthan", 42) }}
|
{{ strings|select("equalto", "mystring") }}
|
|
Similar to a generator comprehension such as:
|
|
.. code-block:: python
|
|
(n for n in numbers if test_odd(n))
|
(n for n in numbers if test_divisibleby(n, 3))
|
|
.. versionadded:: 2.7
|
c S s | S r! r" r& r" r" r% Ú<lambda>ÿ ó z sync_do_select.<locals>.<lambda>F©Úselect_or_reject©r± r/ ró rô r" r" r% Úsync_do_selectã s r> zt.AsyncIterator[V]c Ï s t | |||dd dS )Nc S s | S r! r" r& r" r" r% r9 r: zdo_select.<locals>.<lambda>F©Úasync_select_or_rejectr= r" r" r% Ú do_select s rA c O s t | |||dd dS )a¶ Filters a sequence of objects by applying a test to each object,
|
and rejecting the objects with the test succeeding.
|
|
If no test is specified, each object will be evaluated as a boolean.
|
|
Example usage:
|
|
.. sourcecode:: jinja
|
|
{{ numbers|reject("odd") }}
|
|
Similar to a generator comprehension such as:
|
|
.. code-block:: python
|
|
(n for n in numbers if not test_odd(n))
|
|
.. versionadded:: 2.7
|
c S s | S r! r" r& r" r" r% r9 # r: z sync_do_reject.<locals>.<lambda>Fr; r= r" r" r% Úsync_do_reject s rB c Ï s t | |||dd dS )Nc S s | S r! r" r& r" r" r% r9 - r: zdo_reject.<locals>.<lambda>Fr? r= r" r" r% Ú do_reject& s rC c O s t | |||dd dS )aW Filters a sequence of objects by applying a test to the specified
|
attribute of each object, and only selecting the objects with the
|
test succeeding.
|
|
If no test is specified, the attribute's value will be evaluated as
|
a boolean.
|
|
Example usage:
|
|
.. sourcecode:: jinja
|
|
{{ users|selectattr("is_active") }}
|
{{ users|selectattr("email", "none") }}
|
|
Similar to a generator comprehension such as:
|
|
.. code-block:: python
|
|
(u for user in users if user.is_active)
|
(u for user in users if test_none(user.email))
|
|
.. versionadded:: 2.7
|
c S s | S r! r" r& r" r" r% r9 K r: z$sync_do_selectattr.<locals>.<lambda>Tr; r= r" r" r% Úsync_do_selectattr0 s rD c Ï s t | |||dd dS )Nc S s | S r! r" r& r" r" r% r9 U r: z do_selectattr.<locals>.<lambda>Tr? r= r" r" r% Ú do_selectattrN s rE c O s t | |||dd dS )aF Filters a sequence of objects by applying a test to the specified
|
attribute of each object, and rejecting the objects with the test
|
succeeding.
|
|
If no test is specified, the attribute's value will be evaluated as
|
a boolean.
|
|
.. sourcecode:: jinja
|
|
{{ users|rejectattr("is_active") }}
|
{{ users|rejectattr("email", "none") }}
|
|
Similar to a generator comprehension such as:
|
|
.. code-block:: python
|
|
(u for user in users if not user.is_active)
|
(u for user in users if not test_none(user.email))
|
|
.. versionadded:: 2.7
|
c S s | S r! r" r& r" r" r% r9 q r: z$sync_do_rejectattr.<locals>.<lambda>Tr; r= r" r" r% Úsync_do_rejectattrX s rF c Ï s t | |||dd dS )Nc S s | S r! r" r& r" r" r% r9 { r: z do_rejectattr.<locals>.<lambda>Tr? r= r" r" r% Ú do_rejectattrt s rG )r` r/ Úindentr c C sD | j j}|d }|d }|dk r0| ¡ }||d< t|fd|i|S )a Serialize an object to a string of JSON, and mark it safe to
|
render in HTML. This filter is only for use in HTML documents.
|
|
The returned string is safe to render in HTML documents and
|
``<script>`` tags. The exception is in HTML attributes that are
|
double quoted; either use single quotes or the ``|forceescape``
|
filter.
|
|
:param value: The object to serialize to JSON.
|
:param indent: The ``indent`` parameter passed to ``dumps``, for
|
pretty-printing the value.
|
|
.. versionadded:: 2.9
|
zjson.dumps_functionzjson.dumps_kwargsNrH Údumps)r6 rÅ Úcopyr )r` r/ rH rÅ rI rô r" r" r% Ú do_tojson~ s rK )r± ró rô r c s¨ sNdkrN d¡} dd ¡}r<tdtttj||d}nVz d dd
W n tk
|
r tdd Y nX tjtjd fd d
|
}|S ) Nr7 r9 z Unexpected keyword argument r r r z map requires a filter argumentr: c s j j| dS )N)r± )r6 Z call_filter©r; ©ró r± rô r/ r" r% r ¯ s ÿzprepare_map.<locals>.func) rÒ r r r rC r6 Ú LookupErrorr1 rB )r± ró rô r7 r9 r r" rM r% r6 s
|
ÿ r6 )r± ró rô ÚmodfuncÚ lookup_attrr c sº |rBz d }W n t k
|
r. tdd Y nX tj|d}nd}ttdddz: | d| d
tjtjd fdd W n t k
|
r¨ tY nX fd
|
d S ) Nr z$Missing parameter for attribute namer r% c S s | S r! r" r& r" r" r% Ú transfuncÉ s z+prepare_select_or_reject.<locals>.transfuncr: c s j | ¡S r! )r6 Z call_testrL rM r" r% r Ð s z&prepare_select_or_reject.<locals>.funcc s | S r! r" rL )r rO rQ r" r% r9 Ö r: z*prepare_select_or_reject.<locals>.<lambda>)rN r rC r6 r. r1 rB Úbool)r± ró rô rO rP rP Úoffr" )ró r± r rô rO r/ rQ r% Úprepare_select_or_reject· s "
|
rT )r± r/ ró rô rO rP r c c s0 |r,t | ||||}|D ]}||r|V qd S r! )rT ©r± r/ ró rô rO rP r r; r" r" r% r< Ù s
|
r< c C s> |r:t | ||||}t|2 z3 d H W }||r |V q 6 d S r! )rT r rU r" r" r% r@ é s
|
r@ )6ÚabsrP Úbatchrw r¦ rd rp r9 Zdictsortr- r Zfilesizeformatr r¸ Z forceescapeÚformatr rH rR r^ ÚlastrÙ r r3 rJ r r r Úpprintr² ÚrejectZ
|
rejectattrrg r~ r ÚsafeÚselectZ
|
selectattrÚsliceÚsortÚstringrù r# ÚtitleZtrimÚtruncateÚuniqueri Ú urlencoder Z wordcountZwordwrapZxmlattrZtojson)NN)N)N)T)Frt F)FFN)FN)FN)FN)ry F)ry N)ry N)r¤ )F)NFNNN)rË FF)rÖ Fr× N)rá TNT)r rî )rñ )N)N)N)N)r r )NF)NF)Nr )Nr )N)Ú__doc__r r² ÚreÚtypingr1 Ú collectionsr Ú itertoolsr r Z
|
markupsafer r r Z async_utilsr
|
r r r Ú
|
exceptionsr Zruntimer Úutilsr r r r r r r Ú TYPE_CHECKINGZtyping_extensionsÚter6 r Znodesr r Zsandboxr ÚProtocolr ÚTypeVarÚCallablerB r+ r- r. r5 ÚOptionalÚUnionr* rR rC rN rO rA rV rm r\ r r_ rh rk rl ÚIteratorro rR rv rx Úcompilerz r{ r
r r r r r r r¢ Ú AsyncIterabler£ r§ r« r® r° rµ r¸ r¾ r¿ rÇ rÊ rÕ rà rê rë rí rð rò rõ rø rú r r r r Ú
|
NamedTupler r r! r$ r' r( r) r* r+ Úoverloadr, r2 r4 r8 r> rA rB rC rD rE rF rG rK ÚDictr6 rT r< r@ rV rH ZFILTERSr" r" r" r% Ú<module> s2
|
|
ü
|
û ýü *þ ,þ ÿ þ#4 ÿ þ(
|
ü û ) ûú7 üû!ú üû üû ýü ! üû9 üû þ
|
þ þ"!
|
ùøP ÿ þ 0 úù/ úù7
|
ÿ þ +ý
|
ü ÿ þ ' ýü ( û
|
úS û
|
ú üû üû0 þ þû
|
ú
|
þ1ú
|
û
|
ú
|
û þ û þû þ û þû ÿ þ þ ú #ù ù Ê
|
