| Current File : //proc/self/root/lib/python3/dist-packages/twisted/web/__pycache__/_flatten.cpython-312.pyc |
�
Ϫ�f�F � � � d Z ddlmZ ddlmZ ddlmZ ddlmZ ddl m
Z
ddl m Z ddl
mZmZmZmZmZmZmZmZmZmZmZmZ dd lmZm Z dd
l m Z dd l m Z dd l!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z' dd
l(m)Z)m*Z*m+Z+ ddl,m-Z-m.Z. ed� Z/eZ0 ee1e2e&e"e$e%ee0df ee0 ee0ddf e#ee0 eee0 e3e0f e-f
Z4 dZ5d d�Z6d d�Z7 d d�Z8d d�Z9d d�Z: d d!d�Z;d"d�Z< d#d�Z= d$d�Z> d%d �Z?d&d �Z@y)'zu
Context-free flattener/serializer for rendering Python objects, possibly
complex or arbitrarily nested, as strings.
� )� annotations)� iscoroutine)�BytesIO)�exc_info)�
extract_tb)�
GeneratorType) �Any�Callable� Coroutine� Generator�List�Mapping�Optional�Sequence�Tuple�TypeVar�Union�cast)�Deferred�ensureDeferred)� nativeString)�Failure)�CDATA�CharRef�Comment�Tag�slot� voidElements)�FlattenerError� UnfilledSlot�UnsupportedType)� IRenderable�IRequest�T.Ni c � � t | t � r| j d� } | j dd� j dd� j dd� } | S )a�
Escape some character or UTF-8 byte data for inclusion in an HTML or XML
document, by replacing metacharacters (C{&<>}) with their entity
equivalents (C{&<>}).
This is used as an input to L{_flattenElement}'s C{dataEscaper} parameter.
@param data: The string to escape.
@return: The quoted form of C{data}. If C{data} is L{str}, return a utf-8
encoded string.
�utf-8� &s &� <s <� >s >��
isinstance�str�encode�replace��datas �6/usr/lib/python3/dist-packages/twisted/web/_flatten.py�escapeForContentr2 G sK � � �$�� ��{�{�7�#�� �<�<��h� '� /� /��g� >� F� F�t�W� U�D� �K� c �H � t | t � r| j d� S | S )aG
Escape some character or UTF-8 byte data for inclusion in the top level of
an attribute. L{attributeEscapingDoneOutside} actually passes the data
through unchanged, because L{writeWithAttributeEscaping} handles the
quoting of the text within attributes outside the generator returned by
L{_flattenElement}; this is used as the C{dataEscaper} argument to that
L{_flattenElement} call so that that generator does not redundantly escape
its text output.
@param data: The string to escape.
@return: The string, unchanged, except for encoding.
r& )r+ r, r- r/ s r1 � attributeEscapingDoneOutsider5 Z s" � � �$�� ��{�{�7�#�#� �Kr3 c � � � d� fd� }|S )aU
Decorate a C{write} callable so that all output written is properly quoted
for inclusion within an XML attribute value.
If a L{Tag <twisted.web.template.Tag>} C{x} is flattened within the context
of the contents of another L{Tag <twisted.web.template.Tag>} C{y}, the
metacharacters (C{<>&"}) delimiting C{x} should be passed through
unchanged, but the textual content of C{x} should still be quoted, as
usual. For example: C{<y><x>&</x></y>}. That is the default behavior
of L{_flattenElement} when L{escapeForContent} is passed as the
C{dataEscaper}.
However, when a L{Tag <twisted.web.template.Tag>} C{x} is flattened within
the context of an I{attribute} of another L{Tag <twisted.web.template.Tag>}
C{y}, then the metacharacters delimiting C{x} should be quoted so that it
can be parsed from the attribute's value. In the DOM itself, this is not a
valid thing to do, but given that renderers and slots may be freely moved
around in a L{twisted.web.template} template, it is a condition which may
arise in a document and must be handled in a way which produces valid
output. So, for example, you should be able to get C{<y attr="<x />"
/>}. This should also be true for other XML/HTML meta-constructs such as
comments and CDATA, so if you were to serialize a L{comment
<twisted.web.template.Comment>} in an attribute you should get C{<y
attr="<-- comment -->" />}. Therefore in order to capture these
meta-characters, flattening is done with C{write} callable that is wrapped
with L{writeWithAttributeEscaping}.
The final case, and hopefully the much more common one as compared to
serializing L{Tag <twisted.web.template.Tag>} and arbitrary L{IRenderable}
objects within an attribute, is to serialize a simple string, and those
should be passed through for L{writeWithAttributeEscaping} to quote
without applying a second, redundant level of quoting.
@param write: A callable which will be invoked with the escaped L{bytes}.
@return: A callable that writes data with escaping.
c �H �� �t | � j dd� � y )N� "s ")r2 r. )r0 �writes �r1 �_writez*writeWithAttributeEscaping.<locals>._write� s �� �
� �t�$�,�,�T�9�=�>r3 )r0 �bytes�return�None� )r9 r: s ` r1 �writeWithAttributeEscapingr? m s �� �R?� �Mr3 c �h � t | t � r| j d� } | j dd� S )z�
Escape CDATA for inclusion in a document.
@param data: The string to escape.
@return: The quoted form of C{data}. If C{data} is unicode, return a utf-8
encoded string.
r& � ]]>s ]]]]><![CDATA[>r* r/ s r1 � escapedCDATArB � s. � � �$�� ��{�{�7�#�� �<�<�� 2� 3�3r3 c � � t | t � r| j d� } | j dd� } | r
| dd dk( r| dz
} | S )a�
Within comments the sequence C{-->} can be mistaken as the end of the comment.
To ensure consistent parsing and valid output the sequence is replaced with C{-->}.
Furthermore, whitespace is added when a comment ends in a dash. This is done to break
the connection of the ending C{-} with the closing C{-->}.
@param data: The string to escape.
@return: The quoted form of C{data}. If C{data} is unicode, return a utf-8
encoded string.
r& � -->s -->���N� -� r* r/ s r1 �escapedCommentrH � sJ � � �$�� ��{�{�7�#�� �<�<�� � *�D� ��R�S� �T�!� �� �� �Kr3 c �\ � t |� D ] }|��| |v s� || c S |�|S t | � �)zK
Find the value of the named slot in the given stack of slot data.
)�reversedr )�name�slotData�default� slotFrames r1 �
_getSlotValuerO � sG � � �h�'� !� � � �T�Y�%6� �T�?� "�!� � ��N��4� � r3 c �b � �� t � fd�� �d�fd� }d�fd� }� j ||� �S )z�
Create a new L{Deferred} based on C{d} that will fire and fail with C{d}'s
result or error, but will not modify C{d}'s callback type.
c �$ �� �j � S �N)�cancel)�_�ds �r1 �<lambda>z_fork.<locals>.<lambda>� s
�� ����� r3 c �* �� �j | � | S rR )�callback)�result�d2s �r1 rX z_fork.<locals>.callback� s �� �
� � �F���
r3 c �* �� �j | � | S rR )�errback)�failurerZ s �r1 r\ z_fork.<locals>.errback� s �� �
�
�
�7���r3 )rY r$ r< r$ )r] r r< r )r � addCallbacks)rU rX r\ rZ s ` @r1 �_forkr_ � s/ �� �
� 3�4�B��� �N�N�8�W�%�
�Ir3 c
# �� � ��K � |||f d� �fd�
�d�fd� }t |t t f� r | ||� � yt |t � r,t |j
�|j � } �|� �� yt |t � r, |d� |t |j � � |d� yt |t � r, |d� |t |j � � |d� yt |t � �rÉj |j � |j }|�^|�t! d|� d �� �|j# d
� } d| _ |j% |� }
|
� | � } �| � �� �j' � y|j( s �|j* � �� y |d � t |j( t � r |j( j- d � } n |j( } || � |j. j1 � D ]V \ }
}t |
t � r|
j- d � }
|d
|
z dz � �|t2 t5 |� �� �� |d� �X |j* st7 | � t8 vr0 |d� �|j* t: � �� |d| z dz � y |d� yt |t< t> t@ f� r|D ] } �|� �� � yt |tB � r(d|jD fz } ||j- d � � yt |tF � r |tI |� � �� ytK |� rE |tG jL tO tP tF tR tT tR f |� � � �� ytW jX |� r |j � � } �| |�� �� yt[ |� ��w)at
Make C{root} slightly more flat by yielding all its immediate contents as
strings, deferreds or generators that are recursive calls to itself.
@param request: A request object which will be passed to
L{IRenderable.render}.
@param root: An object to be made flatter. This may be of type C{unicode},
L{str}, L{slot}, L{Tag <twisted.web.template.Tag>}, L{tuple}, L{list},
L{types.GeneratorType}, L{Deferred}, or an object that implements
L{IRenderable}.
@param write: A callable which will be invoked with each L{bytes} produced
by flattening C{root}.
@param slotData: A L{list} of L{dict} mapping L{str} slot names to data
with which those slots will be replaced.
@param renderFactory: If not L{None}, an object that provides
L{IRenderable}.
@param dataEscaper: A 1-argument callable which takes L{bytes} or
L{unicode} and returns L{bytes}, quoted as appropriate for the
rendering context. This is really only one of two values:
L{attributeEscapingDoneOutside} or L{escapeForContent}, depending on
whether the rendering context is within an attribute or not. See the
explanation in L{writeWithAttributeEscaping}.
@return: An iterator that eventually writes L{bytes} to C{write}.
It can yield other iterators or L{Deferred}s; if it yields another
iterator, the caller will iterate it; if it yields a L{Deferred},
the result of that L{Deferred} will be another generator, in which
case it is iterated. See L{_flattenTree} for the trampoline that
consumes said values.
c �$ �� t �| |�||� S rR )�_flattenElement)�newRoot� dataEscaper�
renderFactoryr9 �requestrL s ��r1 � keepGoingz"_flattenElement.<locals>.keepGoing s �� � � �W�e�X�}�k�
�
r3 c �& �� | j �� S rR )� addCallback)rY rg s �r1 �keepGoingAsyncz'_flattenElement.<locals>.keepGoingAsync s �� ��!�!�)�,�,r3 s <![CDATA[rA s <!--rD Nz$Tag wants to be rendered by method "z)" but is not contained in any IRenderableFr( �asciirG s =")r9 r8 r) s </s />z&#%d;)re )
rc � Flattenablerd �$Callable[[Union[bytes, str]], bytes]re �Optional[IRenderable]r9 �Callable[[bytes], object]r< z@Generator[Union[Flattenable, Deferred[Flattenable]], None, None])rY �Deferred[Flattenable]r< rp ).r+ r; r, r rO rK rM r rB r0 r rH r �appendrL �render�
ValueError�clone�lookupRenderMethod�pop�tagName�childrenr- �
attributes�itemsr5 r? r r r2 �tuple�listr r �ordinalr r_ r �
fromCoroutiner r rl �objectr" �
providedByr! )rf �rootr9 rL re rd rj � slotValue� rendererName� rootClone� renderMethodrY rw �k�v�element�escapedrg s ` ` @r1 rb rb � sn �� �� �b =H�/<�+0�
� �
�9�
� -�
� )�
�
J�
�-� �$��� �%�
�k�$� � � �D�$� �!�$�)�)�X�t�|�|�D� �� �"�"� �D�%� �
�l��
�l�4�9�9�%�&�
�f�
� �D�'� "�
�g��
�n�T�Y�Y�'�(�
�f�
� �D�#� �����
�
�&��{�{� � � #� �$� �:�<�.� I>� ?�� � �
�
�5�)�I� #�I� �(�;�;�L�I�L�!�'�9�5�F��F�#� #� �L�L�N� ��|�|��D�M�M�*� *� �
�d� � �d�l�l�C� (��l�l�)�)�'�2�G��l�l�G�
�g���O�O�)�)�+� �D�A�q��!�S�!��H�H�W�%�� �$��(�U�"� #� ��/�7Q�RW�7X��
�
�$�K� � �=�=�L�� 1� � E� �$�K� �D�M�M�+;�<� <� �%�'�/�D�(� )� �&�M� �D�5�$�
�6� 7�� %�G��G�$� $� %� �D�'� "��T�\�\�O�+��
�g�n�n�W�%�&� �D�(� #� �U�4�[�)�)� �T� � � � "� "��Y�x� � 4�f�k� I�J�D�Q�
�
�
�
� � �� %����W�%����d�3�3� �d�#�#�s �O O$c � �x ��
� � K � g �
d� d�
� � fd� }d �
� �fd� � t | ||g dt � g}|rS |d j }t |d � }t |t
� r � � |� d{ ��� }|j
|� |r�S � � y7 � # t $ r |j � Y �(t $ r�}|j � g }|D ]* } |j
| j j d � �, |j
j d � t ||t t � d � � �d}~ww xY w�w)
a�
Make C{root} into an iterable of L{bytes} and L{Deferred} by doing a depth
first traversal of the tree.
@param request: A request object which will be passed to
L{IRenderable.render}.
@param root: An object to be made flatter. This may be of type C{unicode},
L{bytes}, L{slot}, L{Tag <twisted.web.template.Tag>}, L{tuple},
L{list}, L{types.GeneratorType}, L{Deferred}, or something providing
L{IRenderable}.
@param write: A callable which will be invoked with each L{bytes} produced
by flattening C{root}.
@return: A C{Deferred}-returning coroutine that resolves to C{None}.
r c �f �� �j | � �t | � z
��t k\ r �� y y rR )rq �len� BUFFER_SIZE)�bs�buf�bufSize� flushBuffers ���r1 �
bufferedWritez#_flattenTree.<locals>.bufferedWrite� s. �� � �
�
�2���3�r�7��� �k� !� �M� "r3 c �N �� �dkD r �dj � � � � d d �= d�y y )Nr r3 )�join)r� r� r9 s ���r1 r� z!_flattenTree.<locals>.flushBuffer� s+ �� � �Q�;� �#�(�(�3�-� ��A���G� r3 NrE r� � )r� r; r< r= )r< r= )rb r2 �gi_frame�nextr+ r rq �
StopIterationrv � Exception�f_localsr r r )
rf r� r9 r� �stack�framer� �e�roots� generatorr� r� r� s
` @@@r1 � _flattenTreer� s s# �� �� �(
�C��G��� ���}�b�$�@P�Q�-�E� � "��"�I�&�&�E��5��9�o�G��'�8�,� �
� '�-��
�L�L�� !�' �, �M� (�� � � �I�I�K�� F� �I�I�K��E� "�
B� �� � �Y� /� /� 8� 8�� @�A�
B� �L�L�� � ��/� 0� ��E�:�h�j��m�+D�E� E��
F�sM �,D:�9B �,B
�-B �1D:�D:�
B �D7�(D:�*D7�2B D2�2D7�7D:c �. � t t | ||� � S )a
Incrementally write out a string representation of C{root} using C{write}.
In order to create a string representation, C{root} will be decomposed into
simpler objects which will themselves be decomposed and so on until strings
or objects which can easily be converted to strings are encountered.
@param request: A request object which will be passed to the C{render}
method of any L{IRenderable} provider which is encountered.
@param root: An object to be made flatter. This may be of type L{str},
L{bytes}, L{slot}, L{Tag <twisted.web.template.Tag>}, L{tuple},
L{list}, L{types.GeneratorType}, L{Deferred}, or something that
provides L{IRenderable}.
@param write: A callable which will be invoked with each L{bytes} produced
by flattening C{root}.
@return: A L{Deferred} which will be called back with C{None} when C{root}
has been completely flattened into C{write} or which will be errbacked
if an unexpected exception occurs.
)r r� )rf r� r9 s r1 �flattenr� � s � �2 �,�w��e�<� =�=r3 c � �� t � �t | |�j � }|j �fd�� t t
t |� S )a�
Collate a string representation of C{root} into a single string.
This is basically gluing L{flatten} to an L{io.BytesIO} and returning
the results. See L{flatten} for the exact meanings of C{request} and
C{root}.
@return: A L{Deferred} which will be called back with a single UTF-8 encoded
string as its result when C{root} has been completely flattened or which
will be errbacked if an unexpected exception occurs.
c �$ �� �j � S rR )�getvalue)rT �ios �r1 rV z flattenString.<locals>.<lambda>� s
�� �B�K�K�M� r3 )r r� r9 ri r r r; )rf r� rU r� s @r1 �
flattenStringr� � s< �� �
��B����r�x�x�(�A��M�M�)�*� ����� #�#r3 )r0 zUnion[bytes, str]r< r; )r9 ro r< zCallable[[bytes], None]rR )rK r, rL z-Sequence[Optional[Mapping[str, Flattenable]]]rM zOptional[Flattenable]r< rl )rU � Deferred[T]r< r� )rf �Optional[IRequest]r� rl r9 ro rL z)List[Optional[Mapping[str, Flattenable]]]re rn rd rm r< zMGenerator[Union[Generator[Any, Any, Any], Deferred[Flattenable]], None, None])rf r� r� rl r9 ro r< r= )rf r� r� rl r9 ro r< zDeferred[None])rf r� r� rl r< zDeferred[bytes])A�__doc__�
__future__r �inspectr r� r �sysr � tracebackr �typesr �typingr r
r r r
r r r r r r r �twisted.internet.deferr r �twisted.python.compatr �twisted.python.failurer �twisted.web._stanr r r r r r �twisted.web.errorr r r! �twisted.web.iwebr" r# r$ �FlattenableRecursiver; r, r rl r� r2 r5 r? rB rH rO r_ rb r� r� r� r> r3 r1 �<module>r� s� ��
� #� � � � � �
�
�
�
� <� .� *� N� N� K� K� 2� �C�L��� �� � ��� � �� �
��
#�$�� � �
�"�D�$�.�/� � �
!�"�
�h�+�,�f�6J�J�K�� �� � � � ��&�&,� $�,� �,�^ 4� �. &*�!�
�!�;�!� #�!� � !�"�&N$�
�N$�
�N$� %�N$� 8� N$�
)� N$� 6�
N$� S�N$�bF�
�F�'2�F�;T�F� �F�R>�
�>�'2�>�;T�>��>�8$r3