|
Server : Apache System : Linux iad1-shared-b8-43 6.6.49-grsec-jammy+ #10 SMP Thu Sep 12 23:23:08 UTC 2024 x86_64 User : dh_edsupp ( 6597262) PHP Version : 8.2.26 Disable Function : NONE Directory : /lib/python3/dist-packages/genshi/template/__pycache__/ |
Upload File : |
o
!�b�k � @ sZ d Z ddlZddlmZmZ ddlmZ ddlmZm Z m
Z
m Z m Z ddl
mZmZmZ g d�ZdZG d d
� d
e�Ze�e�G d d � d e��Zd
d� ZG dd� de�ZG dd� de�ZG dd� de�ZG dd� de�Z G dd� de�Z G dd� de�Z G dd � d e�Z G d d � d e�Z G d d � d e�Z!G d!d"� d"e�Z"G d#d$� d$e�Z#G d%d&� d&e�Z$dS )'z2Implementation of the various template directives.� N)�QName�Stream)�Path)�TemplateRuntimeError�TemplateSyntaxError�EXPR�_apply_directives�
_eval_expr)�
Expression�_ast�_parse) �AttrsDirective�ChooseDirective�ContentDirective� DefDirective� ForDirective� IfDirective�MatchDirective�OtherwiseDirective�ReplaceDirective�StripDirective�
WhenDirective�
WithDirectivezrestructuredtext enc @ s e Zd ZdZdd� ZdS )�
DirectiveMetaz#Meta class for template directives.c C s$ |� � �dd�|d< t�| |||�S )N� directive� �tagname)�lower�replace�type�__new__)�cls�name�bases�d� r% �</usr/lib/python3/dist-packages/genshi/template/directives.pyr " s zDirectiveMeta.__new__N)�__name__�
__module__� __qualname__�__doc__r r% r% r% r& r s r c @ sN e Zd ZdZdgZ ddd�Zedd� �Zd d
� Zd d � Z edd
d��Z
dS )� Directiveaf Abstract base class for template directives.
A directive is basically a callable that takes three positional arguments:
``ctxt`` is the template data context, ``stream`` is an iterable over the
events that the directive applies to, and ``directives`` is is a list of
other directives on the same stream that need to be applied.
Directives can be "anonymous" or "registered". Registered directives can be
applied by the template author using an XML attribute with the
corresponding name in the template. Such directives should be subclasses of
this base class that can be instantiated with the value of the directive
attribute as parameter.
Anonymous directives are simply functions conforming to the protocol
described above, and can only be applied programmatically (for example by
template filters).
�exprN���c C s | � ||||�| _d S �N)� _parse_exprr, ��self�value�template�
namespaces�lineno�offsetr% r% r& �__init__< s zDirective.__init__c C s | |||g|dd� �R � |fS )a= Called after the template stream has been completely parsed.
:param template: the `Template` object
:param stream: the event stream associated with the directive
:param value: the argument value for the directive; if the directive was
specified as an element, this will be an `Attrs` instance
with all specified attributes, otherwise it will be a
`unicode` object with just the attribute value
:param namespaces: a mapping of namespace URIs to prefixes
:param pos: a ``(filename, lineno, offset)`` tuple describing the
location where the directive was found in the source
This class method should return a ``(directive, stream)`` tuple. If
``directive`` is not ``None``, it should be an instance of the `Directive`
class, and gets added to the list of directives applied to the substream
at runtime. `stream` is an event stream that replaces the original
stream associated with the directive.
� Nr% �r! r3 �streamr2 r4 �posr% r% r& �attach@ s zDirective.attachc K s t �)az Apply the directive to the given stream.
:param stream: the event stream
:param directives: a list of the remaining directives that should
process the stream
:param ctxt: the context data
:param vars: additional variables that should be made available when
Python code is executed
)�NotImplementedError�r1 r: �
directives�ctxt�varsr% r% r& �__call__V s
zDirective.__call__c C s2 d}t | dd �d urd| jj }dt| �j|f S )Nr r, z "%s"z<%s%s>)�getattrr, �sourcer r' )r1 r, r% r% r& �__repr__b s zDirective.__repr__c
C sj z|r
t ||j||jd�pdW S ty4 } z| jd|| jf 7 _t||j|||jp-d ��d}~ww )zpParses the given expression, raising a useful error message when a
syntax error is encountered.
��lookupN�% in expression "%s" of "%s" directiver )r
�filepathrG � SyntaxError�msgr r r6 )r! r, r3 r5 r6 �errr% r% r& r/ h s ��
�
���zDirective._parse_expr�NNr- r- )r- r- ) r' r( r) r* � __slots__r7 � classmethodr< rB rE r/ r% r% r% r& r+ ' s
�
r+ c s$ �fdd���| �f� fdd� � � S )z�Takes the AST representation of an assignment, and returns a
function that applies the assignment of a given value to a dictionary.
c s: t | tj�rt� fdd�| jD ��S t | tj�r| jS d S )Nc s g | ]}� |��qS r% r% )�.0�child��_namesr% r& �
<listcomp>} � z/_assignment.<locals>._names.<locals>.<listcomp>)�
isinstancer �Tuple�tuple�elts�Name�id)�noderR r% r& rS { s
�z_assignment.<locals>._namesc sB t |�tu rtt|��D ] }� | || || � q d S || |< d S r. )r rX �range�len)�datar2 �names�idx)�_assignr% r& rb � s
� z _assignment.<locals>._assignr% )�astr% )rb rS r& � _assignmentw s rd c @ � e Zd ZdZg Zdd� ZdS )r
a_ Implementation of the ``py:attrs`` template directive.
The value of the ``py:attrs`` attribute should be a dictionary or a sequence
of ``(name, value)`` tuples. The items in that dictionary or sequence are
added as attributes to the element:
>>> from genshi.template import MarkupTemplate
>>> tmpl = MarkupTemplate('''<ul xmlns:py="http://genshi.edgewall.org/">
... <li py:attrs="foo">Bar</li>
... </ul>''')
>>> print(tmpl.generate(foo={'class': 'collapse'}))
<ul>
<li class="collapse">Bar</li>
</ul>
>>> print(tmpl.generate(foo=[('class', 'collapse')]))
<ul>
<li class="collapse">Bar</li>
</ul>
If the value evaluates to ``None`` (or any other non-truth value), no
attributes are added:
>>> print(tmpl.generate(foo=None))
<ul>
<li>Bar</li>
</ul>
c �" � ���fdd�}t |� |� ��S )Nc 3 s� � t ��\} \}}}t�j� ��}|r>t|t�r,zt t|��}W n ty+ g }Y n
w t|t�s5|�� }|dd� |D �O }| ||f|fV �D ]}|V qHd S )Nc S s2 g | ]\}}t |�|d urt�|��� pd f�qS r. )r �six� text_type�strip)rP �n�vr% r% r& rT � s ��z>AttrsDirective.__call__.<locals>._generate.<locals>.<listcomp>) �nextr r, rV r �iter�
StopIteration�list�items)�kind�tag�attribr; �attrs�event�r@ r1 r: rA r% r& � _generate� s& �
�
��z*AttrsDirective.__call__.<locals>._generate�r �r1 r: r? r@ rA rw r% rv r& rB � s zAttrsDirective.__call__N�r' r( r) r* rN rB r% r% r% r& r
� s r
c @ � e Zd ZdZg Zedd� �ZdS )r a� Implementation of the ``py:content`` template directive.
This directive replaces the content of the element with the result of
evaluating the value of the ``py:content`` attribute:
>>> from genshi.template import MarkupTemplate
>>> tmpl = MarkupTemplate('''<ul xmlns:py="http://genshi.edgewall.org/">
... <li py:content="bar">Hello</li>
... </ul>''')
>>> print(tmpl.generate(bar='Bye'))
<ul>
<li>Bye</li>
</ul>
c C s` t |�tu rtd|jg|dd � �R � �| j||g|dd � �R � }d |d t||f|d gfS )Nz3The content directive can not be used as an elementr8 r r- )r �dictr rI r/ r �r! r3 r: r2 r4 r; r, r% r% r& r< � s �
� zContentDirective.attachN�r' r( r) r* rN rO r< r% r% r% r& r � s
r c sF e Zd ZdZg d�Zd
dd�Ze� fdd��Zd d
� Zd d � Z � Z
S )r a Implementation of the ``py:def`` template directive.
This directive can be used to create "Named Template Functions", which
are template snippets that are not actually output during normal
processing, but rather can be expanded from expressions in other places
in the template.
A named template function can be used just like a normal Python function
from template expressions:
>>> from genshi.template import MarkupTemplate
>>> tmpl = MarkupTemplate('''<div xmlns:py="http://genshi.edgewall.org/">
... <p py:def="echo(greeting, name='world')" class="message">
... ${greeting}, ${name}!
... </p>
... ${echo('Hi', name='you')}
... </div>''')
>>> print(tmpl.generate(bar='Bye'))
<div>
<p class="message">
Hi, you!
</p>
</div>
If a function does not require parameters, the parenthesis can be omitted
in the definition:
>>> tmpl = MarkupTemplate('''<div xmlns:py="http://genshi.edgewall.org/">
... <p py:def="helloworld" class="message">
... Hello, world!
... </p>
... ${helloworld()}
... </div>''')
>>> print(tmpl.generate(bar='Bye'))
<div>
<p class="message">
Hello, world!
</p>
</div>
)r" �args� star_args�
dstar_args�defaultsNr- c
C s t �| d ||||� t|�j}g | _d | _d | _i | _t|t j
�r�|j j | _
|jD ]}tt d�r<t|t j�r<|jj | _q)| j�|j � q)|jD ]%}|jd u rT|jj | _qG| j�|j� t|j|j||jd�} | | j|j< qGt|dd �rx|jj | _t|dd �r�|jj | _d S d S |j | _
d S )N�StarredrF �starargs�kwargs)r+ r7 r �bodyr r� r� r� rV r �Call�funcr[ r" �hasattrr� r2 �append�keywords�argr
rI rG rC r� r� )
r1 r r3 r4 r5 r6 rc r� �kwd�expr% r% r& r7 s4
�
� zDefDirective.__init__c �. t |�tu r |�d�}tt| ��|||||�S )N�function)r r| �get�superr r< r9 �� __class__r% r& r< $ �
�zDefDirective.attachc s8 t ���� ����fdd�}�j|_|� jd �j< g S )Nc ? s� � i }t | �} �jD ]$}| r| �d�||< q
||v r |�|�}n
t�j�|�� ��}|||< q
�jd ur9| |�j< �jd urC||�j< � �|� t ��� ��D ]}|V qO� �� d S )Nr )
ro r �popr r� r� r� r� �pushr )r r� �scoper" �valru �r@ r? r1 r: rA r% r& r� . s$ �
z'DefDirective.__call__.<locals>.functionr- )ro r" r' �frames)r1 r: r? r@ rA r� r% r� r& rB + s
zDefDirective.__call__c C s dt | �j| jf S �Nz <%s "%s">)r r' r" �r1 r% r% r& rE K s zDefDirective.__repr__�Nr- r- � r' r( r) r* rN r7 rO r< rB rE �
__classcell__r% r% r� r& r � s (
r c sF e Zd ZdZddgZddd�Ze� fdd ��Zd
d � Zd d
� Z � Z
S )r a� Implementation of the ``py:for`` template directive for repeating an
element based on an iterable in the context data.
>>> from genshi.template import MarkupTemplate
>>> tmpl = MarkupTemplate('''<ul xmlns:py="http://genshi.edgewall.org/">
... <li py:for="item in items">${item}</li>
... </ul>''')
>>> print(tmpl.generate(items=[1, 2, 3]))
<ul>
<li>1</li><li>2</li><li>3</li>
</ul>
�assign�filenameNr- c C sp d|vr t d|j||��|�dd�\}}t|d�}d|�� }t|jd j�| _|j| _ t
� | |||||� d S )Nz in z'"in" keyword missing in "for" directiver8 �execziter(%s)r ) r rI �splitr ri rd r� r2 r� r� r+ r7 )r1 r2 r3 r4 r5 r6 r� rc r% r% r& r7 ^ s �
zForDirective.__init__c r� )N�each)r r| r� r� r r< r9 r� r% r& r< i r� zForDirective.attachc
k sr � t | j||�}|d u rd S | j}i }t|�}|D ] }|||� |�|� t||||�D ]} | V q,|�� qd S r. )r r, r� ro r� r r� )
r1 r: r? r@ rA �iterabler� r� �itemru r% r% r& rB p s �
�zForDirective.__call__c C � dt | �j S �Nz<%s>�r r' r� r% r% r& rE � zForDirective.__repr__r� r� r% r% r� r& r O s
r c s0 e Zd ZdZg Ze� fdd��Zdd� Z� ZS )r a� Implementation of the ``py:if`` template directive for conditionally
excluding elements from being output.
>>> from genshi.template import MarkupTemplate
>>> tmpl = MarkupTemplate('''<div xmlns:py="http://genshi.edgewall.org/">
... <b py:if="foo">${bar}</b>
... </div>''')
>>> print(tmpl.generate(foo=True, bar='Hello'))
<div>
<b>Hello</b>
</div>
c r� �N�test)r r| r� r� r r< r9 r� r% r& r< � r� zIfDirective.attachc K s$ t | j||�}|rt||||�S g S r. )r r, r )r1 r: r? r@ rA r2 r% r% r& rB � s zIfDirective.__call__� r' r( r) r* rN rO r< rB r� r% r% r� r& r � s r c @ sB e Zd ZdZg d�Z d
dd�Zedd� �Zd d
� Zd d � Z dS )r a� Implementation of the ``py:match`` template directive.
>>> from genshi.template import MarkupTemplate
>>> tmpl = MarkupTemplate('''<div xmlns:py="http://genshi.edgewall.org/">
... <span py:match="greeting">
... Hello ${select('@name')}
... </span>
... <greeting name="Dude" />
... </div>''')
>>> print(tmpl.generate())
<div>
<span>
Hello Dude
</span>
</div>
)�pathr4 �hintsNr- c C s< t �| d ||||� t||j|�| _|pi | _|pd| _d S )Nr% )r+ r7 r rI r� r4 r� )r1 r2 r3 r� r4 r5 r6 r% r% r& r7 � s
zMatchDirective.__init__c C s� g }t |�tu r:|�dd��� dkr|�d� |�dd��� dkr&|�d� |�dd��� dkr5|�d � |�d
�}| ||t|�|g|d d � �R � |fS ) N�bufferr �false� not_buffered�once�true�
match_once� recursive�
not_recursiver� r8 )r r| r� r r� � frozenset)r! r3 r: r2 r4 r; r� r% r% r& r< � s
�zMatchDirective.attachc K s0 |j �| jjdd�| jt|�| j| j|f� g S )NT)�ignore_context)�_match_templatesr� r� r� ro r� r4 r> r% r% r& rB � s
�zMatchDirective.__call__c C s dt | �j| jjf S r� )r r' r� rD r� r% r% r& rE � s zMatchDirective.__repr__rM )
r' r( r) r* rN r7 rO r< rB rE r% r% r% r& r � s
�
r c @ r{ )r a= Implementation of the ``py:replace`` template directive.
This directive replaces the element with the result of evaluating the
value of the ``py:replace`` attribute:
>>> from genshi.template import MarkupTemplate
>>> tmpl = MarkupTemplate('''<div xmlns:py="http://genshi.edgewall.org/">
... <span py:replace="bar">Hello</span>
... </div>''')
>>> print(tmpl.generate(bar='Bye'))
<div>
Bye
</div>
This directive is equivalent to ``py:content`` combined with ``py:strip``,
providing a less verbose way to achieve the same effect:
>>> tmpl = MarkupTemplate('''<div xmlns:py="http://genshi.edgewall.org/">
... <span py:content="bar" py:strip="">Hello</span>
... </div>''')
>>> print(tmpl.generate(bar='Bye'))
<div>
Bye
</div>
c C sb t |�tu r |�d�}|std|jg|dd � �R � �| j||g|dd � �R � }d t||fgfS )Nr2 z%missing value for "replace" directiver8 )r r| r� r rI r/ r r} r% r% r& r< � s
�
� zReplaceDirective.attachNr~ r% r% r% r& r � s
r c @ re )r a� Implementation of the ``py:strip`` template directive.
When the value of the ``py:strip`` attribute evaluates to ``True``, the
element is stripped from the output
>>> from genshi.template import MarkupTemplate
>>> tmpl = MarkupTemplate('''<div xmlns:py="http://genshi.edgewall.org/">
... <div py:strip="True"><b>foo</b></div>
... </div>''')
>>> print(tmpl.generate())
<div>
<b>foo</b>
</div>
Leaving the attribute value empty is equivalent to a truth value.
This directive is particulary interesting for named template functions or
match templates that do not generate a top-level element:
>>> tmpl = MarkupTemplate('''<div xmlns:py="http://genshi.edgewall.org/">
... <div py:def="echo(what)" py:strip="">
... <b>${what}</b>
... </div>
... ${echo('foo')}
... </div>''')
>>> print(tmpl.generate())
<div>
<b>foo</b>
</div>
c rf )Nc 3 sR � �j r t�j � ��r t�� t��} �D ]}| V |} qd S �D ]}|V q!d S r. )r, r rl )�previousru rv r% r& rw s ���z*StripDirective.__call__.<locals>._generaterx ry r% rv r& rB s
zStripDirective.__call__Nrz r% r% r% r& r � s r c s4 e Zd ZdZddgZe� fdd��Zdd� Z� ZS )r a� Implementation of the ``py:choose`` directive for conditionally selecting
one of several body elements to display.
If the ``py:choose`` expression is empty the expressions of nested
``py:when`` directives are tested for truth. The first true ``py:when``
body is output. If no ``py:when`` directive is matched then the fallback
directive ``py:otherwise`` will be used.
>>> from genshi.template import MarkupTemplate
>>> tmpl = MarkupTemplate('''<div xmlns:py="http://genshi.edgewall.org/"
... py:choose="">
... <span py:when="0 == 1">0</span>
... <span py:when="1 == 1">1</span>
... <span py:otherwise="">2</span>
... </div>''')
>>> print(tmpl.generate())
<div>
<span>1</span>
</div>
If the ``py:choose`` directive contains an expression, the nested
``py:when`` directives are tested for equality to the ``py:choose``
expression:
>>> tmpl = MarkupTemplate('''<div xmlns:py="http://genshi.edgewall.org/"
... py:choose="2">
... <span py:when="1">1</span>
... <span py:when="2">2</span>
... </div>''')
>>> print(tmpl.generate())
<div>
<span>2</span>
</div>
Behavior is undefined if a ``py:choose`` block contains content outside a
``py:when`` or ``py:otherwise`` block. Behavior is also undefined if a
``py:otherwise`` occurs before ``py:when`` blocks.
�matchedr2 c r� r� )r r| r� r� r r< r9 r� r% r& r< Q r� zChooseDirective.attachc k s^ � dt | j�d g}| jrt| j||�|d< |j�|� t||||�D ]}|V q"|j�� d S )NF� )�boolr, r �
_choice_stackr� r r� )r1 r: r? r@ rA �inforu r% r% r& rB X s � zChooseDirective.__call__r� r% r% r� r& r ( s &r c s< e Zd ZdZdgZd dd�Ze� fdd��Zd d
� Z� Z S ) r z�Implementation of the ``py:when`` directive for nesting in a parent with
the ``py:choose`` directive.
See the documentation of the `ChooseDirective` for usage.
r� Nr- c C s t �| |||||� |j| _d S r. �r+ r7 rI r� r0 r% r% r& r7 j � zWhenDirective.__init__c r� r� )r r| r� r� r r< r9 r� r% r& r< n r� zWhenDirective.attachc K s� |j o|j d }|s td| jgt|�d dd � �R � �|d r"g S | js;|d s;td| jgt|�d dd � �R � �|d rU|d }| jrP|t| j||�k}nt|�}n tt| j||��}||d< |sfg S t||||�S )Nr- z>"when" directives can only be used inside a "choose" directiver� r8 r z?either "choose" or "when" directive must have a test expression)r� r r� rl r, r r� r )r1 r: r? r@ rA r� r2 r� r% r% r& rB u s2 ����
zWhenDirective.__call__r� )
r' r( r) r* rN r7 rO r< rB r� r% r% r� r& r b s
r c @ s( e Zd ZdZdgZd dd�Zdd� ZdS )
r z�Implementation of the ``py:otherwise`` directive for nesting in a parent
with the ``py:choose`` directive.
See the documentation of `ChooseDirective` for usage.
r� Nr- c C s t �| d ||||� |j| _d S r. r� r0 r% r% r& r7 � r� zOtherwiseDirective.__init__c K sZ |j o|j d }|s td| jgt|�d dd � �R � �|d r"g S d|d< t||||�S )Nr- zEan "otherwise" directive can only be used inside a "choose" directiver� r8 r T)r� r r� rl r )r1 r: r? r@ rA r� r% r% r& rB � s ��zOtherwiseDirective.__call__r� )r' r( r) r* rN r7 rB r% r% r% r& r � s
r c sD e Zd ZdZdgZd
dd�Ze� fdd��Zd d
� Zd d � Z � Z
S )r a� Implementation of the ``py:with`` template directive, which allows
shorthand access to variables and expressions.
>>> from genshi.template import MarkupTemplate
>>> tmpl = MarkupTemplate('''<div xmlns:py="http://genshi.edgewall.org/">
... <span py:with="y=7; z=x+10">$x $y $z</span>
... </div>''')
>>> print(tmpl.generate(x=42))
<div>
<span>42 7 52</span>
</div>
rA Nr- c
C s� t �| d ||||� g | _|�� }z3t|d�}|jD ]'}t|tj�s*t d|j
||��| j� dd� |j D �t
|j|j
||jd�f� qW d S tyi } z| jd|| jf 7 _t ||j
|||jpbd ��d }~ww )Nr� z8only assignment allowed in value of the "with" directivec S s g | ]}t |��qS r% )rd )rP rj r% r% r& rT � rU z*WithDirective.__init__.<locals>.<listcomp>rF rH r )r+ r7 rA ri r r� rV r �Assignr rI r� �targetsr
r2 rG rJ rK r r6 ) r1 r2 r3 r4 r5 r6 rc r\ rL r% r% r& r7 � s2
�
���
�
���zWithDirective.__init__c r� )NrA )r r| r� r� r r< r9 r� r% r& r< � r� zWithDirective.attachc k sf � i }|� |� | jD ]\}}t|||�}|D ]} | ||� qq t||||�D ]}
|
V q'|�� d S r. )r� rA r r r� ) r1 r: r? r@ rA �framer� r, r2 r� ru r% r% r& rB � s �
� zWithDirective.__call__c C r� r� r� r� r% r% r& rE � r� zWithDirective.__repr__r� r� r% r% r� r& r � s
r )%r* rg � genshi.corer r � genshi.pathr �genshi.template.baser r r r r �genshi.template.evalr
r r �__all__�
__docformat__r r �
add_metaclass�objectr+ rd r
r r r r r r r r r r r r% r% r% r& �<module> s0
O5v4 2'/:.